8个LED的音量表 的思考

囧囧-科技大神粉

原帖：http://www.dianziaihaozhe.com/mulu/guowai/2627.html


下面的音量表电路采用两个四电压比较器（LM339），照亮了一系列的8个LED指示灯，指示音量。每个8比较器的偏置电压的增加由分压器设定为使右下LED点亮时，首先输入的是约400毫伏，或约22毫瓦的峰值在8欧姆系统。分压器的电压被设定为使得每个LED代表大约两倍的功率电平之前，当所有的LED被点亮时，这样的比例范围是从22毫瓦到大约2.5瓦特。灵敏度可与输入控制降低到读更高的水平。

我还没有建立或测试该电路，功率电平应该如下：

1个LED = 22MW
2个LED = 42MW
3个LED = 90mW的
4个LED =为175mW
5个LED =达320mW
6个LED =为650mW
7个LED = 1.2瓦
8个LED =2.5瓦特

————————————————————————————————————————————————

衍生，楼主想直接测3.5耳机音频孔出来的电压，就用这个电路，但根据其他论坛大神的描述，峰值电压最高不过1Vpp，均值不过700mVpp，显然不太适合则个阻值，目测原文作者的阻值是接在功放出口的，所以能达到这么大

现在，楼主想改成同相输入端为10mV、20mV、30mV、40mV、50mV、60mV、70mV、80mV，这种小电压的

那么问题来了，Vcc端5V，要分出80mV的，根据串联分压来说，如果R1为1200欧（8个150欧），那么R2需要73800欧

坑爹啊～～～楼主压根就没这么多的电阻（73800约要16个4.7k电阻）怎么办？

苦思冥想后，祭出一个神气，5.1V的稳压二极管，然后串联一个4.7K+1.57K（3个4.7K并联）+8个150欧

进而实现了，实测5.1V稳压管实际降压大概4.48V，剩下0.5V左右就比较好分了

http://www.tudou.com/listplay/NCZI5vbIFQE/IUKGSm4mutQ.html

——————————————————————————————————————————

另外，再附上1种单片机读音频的电路

囧囧-科技大神粉

1. /*
   
2. 纯串口控制
   
3.   加入脱机控制
   
4. */
   
5. 
   
6. 
   
7. //电机的高电平持续时间 us
   
8. int maichongjiangeMax=357;
   
9. int maichongjiangeMin=120;
   
10. 
    
11. //电机的高电平持续时间的初始值 120us
    
12. int maichongjiange=357;
    
13. 
    
14. // EN+,脱机，高电平有效
    
15. // CW+,方向
    
16. // CLK+,频率（转速）
    
17. int EN=10;
    
18. int CW=11;
    
19. int CLK=12;
    
20. 
    
21. 
    
22. //脉冲的占空比为1/maichongzhankongbi
    
23. int maichongzhankongbi=4;
    
24. 
    
25. ////////////////////////////////////////////
    
26. 
    
27. int tempint;
    
28. int maichongjsq=0;//脉冲计数器
    
29. 
    
30. 
    
31. unsigned long time2=micros();
    
32. 
    
33. 
    
34. void setup(){
    
35. 
    
36. Serial.begin(9600);
    
37. 
    
38. pinMode(EN, OUTPUT);// EN+,脱机，高电平有效
    
39. pinMode(CW, OUTPUT);// CW+,方向
    
40. pinMode(CLK, OUTPUT);// CLK+,频率（转速）
    
41. 
    
42. digitalWrite(EN, HIGH);//电机默认脱机
    
43. digitalWrite(CW, LOW);//
    
44. digitalWrite(CLK, LOW);
    
45. 
    
46. for(int col=2;col<10;col++)pinMode(col, INPUT_PULLUP);
    
47. 
    
48. }
    
49. 
    
50. 
    
51. void loop(){
    
52. 
    
53. 
    
54. 
    
55. 
    
56.    while (Serial.available() > 0) {
    
57. 
    
58.     //丧心病狂的单字节控制，0延迟，纯ASCII分拆
    
59.         //定义1 0-9表示转速，每一个表示10%
    
60.         //定义2 A正转、B反转
    
61.         //定义3 C联机、D脱机
    
62. 
    
63.    tempint=Serial.read();
    
64. 
    
65.    //调速度
    
66.    if(tempint>47 && tempint< 58) maichongjiange = 625/(1.75+3.25*(tempint-48)/10);//0-1023
    
67.    //调方向
    
68.    else if(tempint==65)digitalWrite(CW, 0);
    
69.    else if(tempint==66)digitalWrite(CW, 1);
    
70.     //脱机
    
71.    else if(tempint==67)digitalWrite(EN, 0);
    
72.    else if(tempint==68)digitalWrite(EN, 1);
    
73. 
    
74. //E jiansu   F jiasu
    
75.    else if(tempint==69){
    
76.     maichongjiange=maichongjiange+3;
    
77.     if(maichongjiange>maichongjiangeMax)maichongjiange=maichongjiangeMax;
    
78.    }
    
79.    else if(tempint==70){
    
80.     maichongjiange=maichongjiange-3;
    
81.     if(maichongjiange<maichongjiangeMin)maichongjiange=maichongjiangeMin;
    
82.    }
    
83. 
    
84. 
    
85.    Serial.println(maichongjiange);
    
86.    tempint=0;
    
87. 
    
88. }
    
89. 
    
90. 
    
91. 
    
92. for(int col=10;col>1;col--){
    
93. 
    
94.      tempint= digitalRead(col);
    
95.          if(tempint==LOW){
    
96.                  Serial.print("Max:");
    
97.                  Serial.println(col);
    
98.                  col=0;
    
99. 
    
100.          }
     
101. 
     
102. }
     
103. 
     
104. //在脉冲频率无变化的时候驱动电机正常运行
     
105. maichongqudong();
     
106. 
     
107. 
     
108. }
     
109. 
     
110. 
     
111. 
     
112. void maichongqudong()//脉冲驱动
     
113. {
     
114. 
     
115. //步进电机控制脉冲
     
116. if (micros()-time2 > maichongjiange){
     
117. 
     
118.         maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
     
119.         maichongjsq=maichongjsq%maichongzhankongbi;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
     
120. 
     
121.         if(maichongjsq==0)digitalWrite(CLK, HIGH);//输出控制步进电机的电平
     
122.         else digitalWrite(CLK, LOW);
     
123. 
     
124.      time2= micros();
     
125. }
     
126. 
     
127. }
     

复制代码

囧囧-科技大神粉

音压、电机联动，最粗暴的一版

1. /*
   
2. 纯串口控制
   
3.   加入脱机控制
   
4. */
   
5. 
   
6. 
   
7. //电机的高电平持续时间 us
   
8. int maichongjiangeMax=357;
   
9. int maichongjiangeMin=120;
   
10. 
    
11. //电机的高电平持续时间的初始值 120us
    
12. int maichongjiange=357;
    
13. 
    
14. // EN+,脱机，高电平有效
    
15. // CW+,方向
    
16. // CLK+,频率（转速）
    
17. int EN=10;
    
18. int CW=11;
    
19. int CLK=12;
    
20. 
    
21. 
    
22. //脉冲的占空比为1/maichongzhankongbi
    
23. int maichongzhankongbi=4;
    
24. 
    
25. ////////////////////////////////////////////
    
26. 
    
27. int tempint;//打杂的中间数
    
28. 
    
29. 
    
30. int shuaijianzhi;//衰减值
    
31. 
    
32. int maichongjsq=0;//脉冲计数器
    
33. 
    
34. boolean zusaiqu=0;//阻塞区
    
35. 
    
36. 
    
37. unsigned long time1=micros();//电机CLK
    
38. 
    
39. unsigned long time2=millis();//防止因音频变化而过快的改变电机的运行状态
    
40. 
    
41. 
    
42. void setup(){
    
43. 
    
44. Serial.begin(9600);
    
45. 
    
46. pinMode(EN, OUTPUT);// EN+,脱机，高电平有效
    
47. pinMode(CW, OUTPUT);// CW+,方向
    
48. pinMode(CLK, OUTPUT);// CLK+,频率（转速）
    
49. 
    
50. digitalWrite(EN, HIGH);//电机默认脱机
    
51. digitalWrite(CW, LOW);//
    
52. digitalWrite(CLK, LOW);
    
53. 
    
54. for(int col=2;col<10;col++)pinMode(col, INPUT_PULLUP);
    
55. 
    
56. }
    
57. 
    
58. 
    
59. void loop(){
    
60. 
    
61. 
    
62. 
    
63. //串口调速
    
64.    while (Serial.available() > 0) {
    
65. 
    
66.     //丧心病狂的单字节控制，0延迟，纯ASCII分拆
    
67.         //定义1 0-9表示转速，每一个表示10%
    
68.         //定义2 A正转、B反转
    
69.         //定义3 C联机、D脱机
    
70. 
    
71.    tempint=Serial.read();
    
72. 
    
73.    //调速度
    
74.    if(tempint>47 && tempint< 58) maichongjiange = 625/(1.75+3.25*(tempint-48)/10);//0-1023
    
75.    //调方向
    
76.    else if(tempint==65)digitalWrite(CW, 0);
    
77.    else if(tempint==66)digitalWrite(CW, 1);
    
78.     //脱机
    
79.    else if(tempint==67)digitalWrite(EN, 0);
    
80.    else if(tempint==68)digitalWrite(EN, 1);
    
81. 
    
82. //E jiansu   F jiasu
    
83.    else if(tempint==69){
    
84.     maichongjiange=maichongjiange+3;
    
85.     if(maichongjiange>maichongjiangeMax)maichongjiange=maichongjiangeMax;
    
86.    }
    
87.    else if(tempint==70){
    
88.     maichongjiange=maichongjiange-3;
    
89.     if(maichongjiange<maichongjiangeMin)maichongjiange=maichongjiangeMin;
    
90.    }
    
91. 
    
92. 
    
93.    Serial.println(maichongjiange);
    
94.    tempint=0;
    
95. 
    
96. }
    
97. 
    
98. 
    
99. 
    
100. //音频调速
     
101. 
     
102. if(!zusaiqu){ //阻塞区内不做判断，最粗暴，完善的方法是，阻塞区内低值无效，高值有效
     
103. 
     
104.         for(int col=9;col>1;col--){
     
105. 
     
106.                 tempint= digitalRead(col);
     
107.                
     
108.          if(!tempint){ //低电平有效
     
109.                                 zusaiqu=1;//进入阻塞期间
     
110.                 // Serial.print("Max:"); //实际情况是其发送非常耗时，直接影响了步进电机的运行
     
111.                 // Serial.println(col);
     
112.                                 //对于速度增加的定义，鉴于其返回值有9、8····2端口值，先粗暴一把吧，直接按声压，而非实际分贝分类
     
113.                                 maichongjiange = 625/(1.75+3.25*(col-1)/8);//
     
114.                                 
     
115.                                 //确定衰减值
     
116.                                 shuaijianzhi=(maichongjiangeMax-maichongjiange)/3;
     
117.         
     
118.    
     
119.                 col=0;//跳出循环
     
120.          }
     
121.         }
     
122. 
     
123. 
     
124. }else{
     
125.          
     
126.          
     
127. //核心部分，转速的衰减，暂定为3秒，即声压带来的速度提升效果，会在3秒后消失
     
128. //那么就意味，只有最慢的357才是常态，其他都是浮云
     
129. //衰减暂定为3部曲，每秒衰减1/3，梯形衰减，不做平滑处理（平滑的效果反而很差，因为不是闭环）
     
130.         if (millis() - time2 > 1000 && shuaijianzhi>0){
     
131.         time2=millis();
     
132.         
     
133.                         maichongjiange=maichongjiange+shuaijianzhi; //脉冲周期增加，频率下降，转速衰减
     
134.                         
     
135.                         if(maichongjiange>maichongjiangeMax){
     
136.                                 maichongjiange=maichongjiangeMax;//防止过度衰减
     
137.                                 zusaiqu=0;//退出阻塞期间
     
138.                                 shuaijianzhi=0;//衰减值归零
     
139.                                 
     
140.                         }
     
141. 
     
142.         }
     
143. 
     
144. 
     
145. 
     
146. }
     
147. 
     
148. 
     
149. 
     
150. //在脉冲频率无变化的时候驱动电机正常运行
     
151. maichongqudong();
     
152. 
     
153. 
     
154. 
     
155. 
     
156. 
     
157. 
     
158. }
     
159. 
     
160. 
     
161. 
     
162. void maichongqudong()//脉冲驱动
     
163. {
     
164. 
     
165. //步进电机控制脉冲
     
166. if (micros()-time1 > maichongjiange){
     
167. 
     
168.         maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
     
169.         maichongjsq=maichongjsq%maichongzhankongbi;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
     
170. 
     
171.         if(maichongjsq==0)digitalWrite(CLK, HIGH);//输出控制步进电机的电平
     
172.         else digitalWrite(CLK, LOW);
     
173. 
     
174.      time1= micros();
     
175. }
     
176. 
     
177. }
     

复制代码

囧囧-科技大神粉

音频电压控制电机精细版_修正音频电压与转速的关系

在16欧耳机内阻的情况下涵盖41-59db，共18db的音频变化，范围太窄，这个需要改进

囧囧-科技大神粉

/*
纯串口控制
  加入脱机控制
  加入细分变量 xifen 用1250/xifen 取代625
  单周期高电平US——圈/S ：= (1000000/(X*200))/xifen*0.25=xifen2/X=xifen2/X

*/


//电机的高电平持续时间 us
int maichongjiangeMax=357;
int maichongjiangeMin=120;

//电机的高电平持续时间的初始值 120us
int maichongjiange=357;

// EN+,脱机，高电平有效
// CW+,方向
// CLK+,频率（转速）
int EN=10;
int CW=11;
int CLK=12;

//步进电机控制器的细分数1、2、8、16（整、半、1/8、1/16）、
int xifen=8;
int xifen2;

//10步距角
int bujujiao=18;
//100度所需的色脉冲数,把度数放大，可以极大的提高控制精度，
int dumaichong100;

//脉冲的占空比为1/maichongzhankongbi
int maichongzhankongbi=4;

////////////////////////////////////////////

int tempint;//打杂的中间数

int yunxingmoshi;//运行模式
int moshijsq=0;//模式计数器
boolean fangxiang=0;//电机转动方向标识
int fanzhuanfazhi=0;

float quanshuzy;//圈数增益（量）每秒，作为感官等额衰减的依据
int tempint2;//打杂的中间数2，专注记录，maichongjiange的变化

int maichongjsq=0;//脉冲计数器




unsigned long time1=micros();//电机CLK

unsigned long time2=millis();//防止因音频变化而过快的改变电机的运行状态


void setup(){

Serial.begin(9600);

pinMode(EN, OUTPUT);// EN+,脱机，高电平有效
pinMode(CW, OUTPUT);// CW+,方向
pinMode(CLK, OUTPUT);// CLK+,频率（转速）

digitalWrite(EN, HIGH);//电机默认脱机
digitalWrite(CW, LOW);//
digitalWrite(CLK, LOW);

for(int col=2;col<10;col++)pinMode(col, INPUT_PULLUP);

xifen2=1250/xifen;
dumaichong100=xifen*10/bujujiao; //55(1)        \        111(2)        \        444(8)        \        888(16)
maichongjiangeMax=maichongjiangeMax*2/xifen;
maichongjiangeMin=maichongjiangeMin*2/xifen;

}


void loop(){



//串口调速
   while (Serial.available() > 0) {

    //丧心病狂的单字节控制，0延迟，纯ASCII分拆
        //定义1 0-9表示转速，每一个表示10%
        //定义2 A正转、B反转
        //定义3 C联机、D脱机

   tempint=Serial.read();

   //调速度
   if(tempint>47 && tempint< 58) maichongjiange = xifen2/(1.75+3.25*(tempint-48)/10);//0-1023
   //调方向 A、B
   else if(tempint==65){
    digitalWrite(CW, 0);
    fangxiang=0;
   }
   else if(tempint==66){
    digitalWrite(CW, 1);
    fangxiang=1;
   }
    //联机、脱机 C、D
   else if(tempint==67)digitalWrite(EN, 0);
   else if(tempint==68)digitalWrite(EN, 1);

//E 减速   F 加速
   else if(tempint==69){
    maichongjiange=maichongjiange+3;
    if(maichongjiange>maichongjiangeMax)maichongjiange=maichongjiangeMax;
   }
   else if(tempint==70){
    maichongjiange=maichongjiange-3;
    if(maichongjiange<maichongjiangeMin)maichongjiange=maichongjiangeMin;
   }
   
   //模式G 转动
   else if(tempint==71)yunxingmoshi=0;
   //模式H 摇摆
   else if(tempint==72)yunxingmoshi=1;
   //模式J
   //else if(tempint==73)yunxingmoshi=2;
   
   


   Serial.println(maichongjiange);
   tempint=0;

}



//音频调速

  //阻塞区内不做判断，最粗暴，完善的方法是，阻塞区内低值无效，高值有效

        for(int col=9;col>1;col--){

                tempint= digitalRead(col);
               
         if(!tempint){ //低电平有效
               
                // Serial.print("Max:"); //实际情况是其发送非常耗时，直接影响了步进电机的运行
                // Serial.println(col);
                                //对于速度增加的定义，鉴于其返回值有9、8····2端口值，先粗暴一把吧，直接按声压，而非实际分贝分类
                               // tempint2 = xifen2/(1.75+3.25*(col-1)/8);//在变化有效的情况下，maichongjiange的值得
          //实际人耳的分类，与电压、耳机灵敏度有关
          //现在以100db/mw灵敏度的耳机进行分类
          //目前实测，2个LM339的，8个基准脚的电压与接口、分贝对于关系为
          /*
        IO        2        \        3        \        4        \        5        \        6        \        7        \        8        \        9
        基准mV        6.5        \        12.9\        19.5\        26.1\        33        \        39.8\        46.2\        53.1
      32欧对应db        41.2\        47.1\        50.7\        53.2\        55.3\        56.9\        58.2\        59.4
      16欧对应db        44.2\        50.1\        53.7\        56.2\        58.3\        59.9\        61.2\        62.4
      定义每个等级增加 0.40625圈，8个增量 =3.25圈
     
        可见
        1、耳机内阻减小虽然会导致功率翻倍，但分贝数不过变化3
        2、坑爹啊，基准值取得太高，导致范围曲在了41-59db，所需音量太大（电脑音量输出50%以上），且范围窄（小于提速无效，大于衰减无效）
        3、如果在32欧内阻下测量，需要细分到2mV（31db）、3mV（34db）、4mv（36.9db），328p分辨率不足，LM339的10mv分辨率更不足，需要放大
         
          */
      
        tempint2 = xifen2/(1.75+0.40625*(col-1));//在变化有效的情况下，maichongjiange的值得
      
                                //仅当新值低于现值（周期短，频率高），此变化才是有效的
        if(maichongjiange>tempint2){
   maichongjiange=tempint2;
   
   if(yunxingmoshi==1)fanzhuanfazhi=5*col;//反转阀值度数的确定，取端口值的5倍数
  }



      
                col=0;//跳出循环
         }
        }



         
         
//核心部分，转速的衰减，暂定为3秒，即声压带来的速度提升效果，会在3秒后消失
//那么就意味，只有最慢的357才是常态，其他都是浮云
//衰减暂定为3部曲，每秒衰减1/3，梯形衰减，不做平滑处理（平滑的效果反而很差，因为不是闭环）
        if (millis() - time2 > 1000){
        time2=millis();

                  //确定衰减值，这次是动态计算，理想中省资源的方式是直接分类
      //先确定增益圈数
      quanshuzy=xifen2/maichongjiange - 1.75;//等价 xifen2/maichongjiange - xifen2/maichongjiangeMax
         
                        //每次衰减增益数的20%
      //等价xifen2/(1.75+quanshuzy*0.8)
      //理论上，只要quanshuzy不为负，就速度下限就是1.75圈/秒，但328p的浮点不靠谱性得防
      if(quanshuzy>0){
      
       maichongjiange=xifen2/(1.75+quanshuzy*0.8); //脉冲周期增加，频率下降，转速衰减
   
    if(yunxingmoshi==1 && fanzhuanfazhi>10)fanzhuanfazhi=fanzhuanfazhi*0.8;//H模式下，同转速，每次衰减20%
   
      }else{
      
    fanzhuanfazhi=5;
       quanshuzy=0;
      }
      

        }






//在脉冲频率无变化的时候驱动电机正常运行
maichongqudong();






}



void maichongqudong()//脉冲驱动
{

//步进电机控制脉冲
if (micros()-time1 > maichongjiange){

        maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
        maichongjsq=maichongjsq%maichongzhankongbi;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0

        if(maichongjsq==0){
   
   digitalWrite(CLK, HIGH);//输出控制步进电机的电平
   
///////////////////////////////////////////////////////////////////////////////////
   //H模式
    if(yunxingmoshi==1){
     //对于脉冲数的计数
    if(fangxiang)moshijsq++;
    else moshijsq--;

    //反转阀值折算为脉冲数进行反转
    tempint=fanzhuanfazhi*dumaichong100/100; // 需要度数*100度所需周期数
   
    if(moshijsq<-tempint || moshijsq>tempint){ //达到既定周期后反向
     fangxiang=!fangxiang;
     digitalWrite(CW, fangxiang);
    }
   }


/////////////////////////////////////////////////////////////////////////////////////

  }else digitalWrite(CLK, LOW);


     time1= micros();
}



}

囧囧-科技大神粉

1. /*
   
2. 纯串口控制
   
3.   加入脱机控制
   
4.   加入细分变量 xifen 用1250/xifen 取代625
   
5.   单周期高电平US——圈/S ：= (1000000/(X*200))/xifen*0.25=xifen2/X=xifen2/X
   
6. 
   
7. */
   
8. 
   
9. 
   
10. //电机的高电平持续时间 us
    
11. int maichongjiangeMax=1563;
    
12. int maichongjiangeMin=174;
    
13. 
    
14. //电机的高电平持续时间的初始值 120us
    
15. int maichongjiange=357;
    
16. 
    
17. // EN+,脱机，高电平有效
    
18. // CW+,方向
    
19. // CLK+,频率（转速）
    
20. int EN=10;
    
21. int CW=11;
    
22. int CLK=12;
    
23. 
    
24. //步进电机控制器的细分数1、2、8、16（整、半、1/8、1/16）、
    
25. int xifen=8;
    
26. int xifen2;
    
27. 
    
28. //10步距角
    
29. int bujujiao=18;
    
30. //100度所需的色脉冲数,把度数放大，可以极大的提高控制精度，
    
31. int dumaichong100;
    
32. 
    
33. //脉冲的占空比为1/maichongzhankongbi
    
34. int maichongzhankongbi=4;
    
35. 
    
36. ////////////////////////////////////////////
    
37. 
    
38. int tempint;//打杂的中间数
    
39. 
    
40. int yunxingmoshi;//运行模式
    
41. int moshijsq=0;//模式计数器
    
42. boolean fangxiang=0;//电机转动方向标识
    
43. int fanzhuanfazhi=0;
    
44. 
    
45. float quanshuzy;//圈数增益（量）每秒，作为感官等额衰减的依据
    
46. int tempint2;//打杂的中间数2，专注记录，maichongjiange的变化
    
47. 
    
48. int maichongjsq=0;//脉冲计数器
    
49. 
    
50. 
    
51. 
    
52. 
    
53. unsigned long time1=micros();//电机CLK
    
54. 
    
55. unsigned long time2=millis();//防止因音频变化而过快的改变电机的运行状态
    
56. 
    
57. 
    
58. void setup(){
    
59. 
    
60. Serial.begin(9600);
    
61. 
    
62. pinMode(EN, OUTPUT);// EN+,脱机，高电平有效
    
63. pinMode(CW, OUTPUT);// CW+,方向
    
64. pinMode(CLK, OUTPUT);// CLK+,频率（转速）
    
65. 
    
66. digitalWrite(EN, HIGH);//电机默认脱机
    
67. digitalWrite(CW, LOW);//
    
68. digitalWrite(CLK, LOW);
    
69. 
    
70. for(int col=2;col<10;col++)pinMode(col, INPUT_PULLUP);
    
71. 
    
72. xifen2=1250/xifen;
    
73. dumaichong100=xifen*1000/bujujiao; //55(1)        \        111(2)        \        444(8)        \        888(16)
    
74. 
    
75. }
    
76. 
    
77. 
    
78. void loop(){
    
79. 
    
80. 
    
81. 
    
82. //串口调速
    
83.    while (Serial.available() > 0) {
    
84. 
    
85.     //丧心病狂的单字节控制，0延迟，纯ASCII分拆
    
86.         //定义1 0-9表示转速，每一个表示10%
    
87.         //定义2 A正转、B反转
    
88.         //定义3 C联机、D脱机
    
89. 
    
90.    tempint=Serial.read();
    
91. 
    
92.    //调速度
    
93.    if(tempint>47 && tempint< 57) maichongjiange = xifen2/(0.1+0.1*(tempint-48));//0-1023
    
94.    //调方向 A、B
    
95.    else if(tempint==65){
    
96.     digitalWrite(CW, 0);
    
97.     fangxiang=0;
    
98.    }
    
99.    else if(tempint==66){
    
100.     digitalWrite(CW, 1);
     
101.     fangxiang=1;
     
102.    }
     
103.     //联机、脱机 C、D
     
104.    else if(tempint==67)digitalWrite(EN, 0);
     
105.    else if(tempint==68)digitalWrite(EN, 1);
     
106. 
     
107. //E 减速   F 加速
     
108.    else if(tempint==69){
     
109.     maichongjiange=maichongjiange+3;
     
110.     if(maichongjiange>maichongjiangeMax)maichongjiange=maichongjiangeMax;
     
111.    }
     
112.    else if(tempint==70){
     
113.     maichongjiange=maichongjiange-3;
     
114.     if(maichongjiange<maichongjiangeMin)maichongjiange=maichongjiangeMin;
     
115.    }
     
116. 
     
117.    //模式G 转动
     
118.    else if(tempint==71)yunxingmoshi=0;
     
119.    //模式H 摇摆
     
120.    else if(tempint==72)yunxingmoshi=1;
     
121. 
     
122.    else tempint=0;
     
123. 
     
124. 
     
125. 
     
126. 
     
127.    Serial.println(maichongjiange);
     
128.    tempint=0;
     
129. 
     
130. }
     
131. 
     
132. 
     
133. 
     
134. //音频调速
     
135. 
     
136.   //阻塞区内不做判断，最粗暴，完善的方法是，阻塞区内低值无效，高值有效
     
137. 
     
138.         for(int col=9;col>1;col--){
     
139. 
     
140.                 tempint= digitalRead(col);
     
141. 
     
142.          if(!tempint){ //低电平有效
     
143. 
     
144.                 // Serial.print("Max:"); //实际情况是其发送非常耗时，直接影响了步进电机的运行
     
145.                 // Serial.println(col);
     
146.                                 //对于速度增加的定义，鉴于其返回值有9、8····2端口值，先粗暴一把吧，直接按声压，而非实际分贝分类
     
147.                                // tempint2 = xifen2/(1.75+3.25*(col-1)/8);//在变化有效的情况下，maichongjiange的值得
     
148.           //实际人耳的分类，与电压、耳机灵敏度有关
     
149.           //现在以100db/mw灵敏度的耳机进行分类
     
150.           //目前实测，2个LM339的，8个基准脚的电压与接口、分贝对于关系为
     
151.           /*
     
152.         IO        2        \        3        \        4        \        5        \        6        \        7        \        8        \        9
     
153.         基准mV        6.5        \        12.9\        19.5\        26.1\        33        \        39.8\        46.2\        53.1
     
154.       32欧对应db        41.2\        47.1\        50.7\        53.2\        55.3\        56.9\        58.2\        59.4
     
155.       16欧对应db        44.2\        50.1\        53.7\        56.2\        58.3\        59.9\        61.2\        62.4
     
156.       定义每个等级增加 0.1圈，8个增量 =0.8圈
     
157. 
     
158.         可见
     
159.         1、耳机内阻减小虽然会导致功率翻倍，但分贝数不过变化3
     
160.         2、坑爹啊，基准值取得太高，导致范围曲在了41-59db，所需音量太大（电脑音量输出50%以上），且范围窄（小于提速无效，大于衰减无效）
     
161.         3、如果在32欧内阻下测量，需要细分到2mV（31db）、3mV（34db）、4mv（36.9db），328p分辨率不足，LM339的10mv分辨率更不足，需要放大
     
162. 
     
163.           */
     
164. 
     
165.         tempint2 = xifen2/(0.1*col);//在变化有效的情况下，maichongjiange的值得
     
166. 
     
167.                                 //仅当新值低于现值（周期短，频率高），此变化才是有效的
     
168.         if(maichongjiange>tempint2){
     
169.    maichongjiange=tempint2;
     
170. 
     
171.    if(yunxingmoshi==1)fanzhuanfazhi=5*col;//反转阀值度数的确定，取端口值的5倍数
     
172.   }
     
173. 
     
174. 
     
175. 
     
176. 
     
177.                 col=0;//跳出循环
     
178.          }
     
179.         }
     
180. 
     
181. 
     
182. 
     
183. 
     
184. 
     
185. //核心部分，转速的衰减，暂定为3秒，即声压带来的速度提升效果，会在3秒后消失
     
186. //那么就意味，只有最慢的357才是常态，其他都是浮云
     
187. //衰减暂定为3部曲，每秒衰减1/3，梯形衰减，不做平滑处理（平滑的效果反而很差，因为不是闭环）
     
188.         if (millis() - time2 > 1000){
     
189. 
     
190. 
     
191.                   //确定衰减值，这次是动态计算，理想中省资源的方式是直接分类
     
192.       //先确定增益圈数
     
193.                 quanshuzy=xifen2/maichongjiange - 0.1;//等价 xifen2/maichongjiange - xifen2/maichongjiangeMax
     
194. 
     
195.                         //每次衰减增益数的20%
     
196. 
     
197.       //理论上，只要quanshuzy不为负，就速度下限就是0.1圈/秒，但328p的浮点不靠谱性得防
     
198.       if(maichongjiangeMax>maichongjiange){
     
199. 
     
200.        maichongjiange=xifen2/(0.1+quanshuzy*0.8); //脉冲周期增加，频率下降，转速衰减
     
201. 
     
202.     if(yunxingmoshi==1 && fanzhuanfazhi>10)fanzhuanfazhi=fanzhuanfazhi*0.8;//H模式下，同转速，每次衰减20%
     
203. 
     
204.       }else{
     
205. 
     
206.     fanzhuanfazhi=5;
     
207.        maichongjiange=maichongjiangeMax;
     
208.       }
     
209. 
     
210.             time2=millis();
     
211. 
     
212.         }
     
213. 
     
214. 
     
215. 
     
216. 
     
217. 
     
218. 
     
219. //在脉冲频率无变化的时候驱动电机正常运行
     
220. maichongqudong();
     
221. 
     
222. 
     
223. 
     
224. }
     
225. 
     
226. 
     
227. 
     
228. void maichongqudong()//脉冲驱动
     
229. {
     
230. 
     
231. 
     
232. 
     
233.         maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
     
234.         maichongjsq=maichongjsq%maichongzhankongbi;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
     
235. 
     
236.         if(maichongjsq==0){
     
237. 
     
238.                         digitalWrite(CLK, HIGH);//输出控制步进电机的电平
     
239. 
     
240. ///////////////////////////////////////////////////////////////////////////////////
     
241.                                 //H模式
     
242.                                     if(yunxingmoshi==1){
     
243.                                      //对于脉冲数的计数
     
244.                                     if(fangxiang)moshijsq++;
     
245.                                     else moshijsq--;
     
246. 
     
247.                                     //反转阀值折算为脉冲数进行反转
     
248.                                     tempint=fanzhuanfazhi*dumaichong100/100; // 需要度数*100度所需周期数
     
249. 
     
250.                                     if(moshijsq<-tempint || moshijsq>tempint){ //达到既定周期后反向
     
251.                                      fangxiang=!fangxiang;
     
252.                                      digitalWrite(CW, fangxiang);
     
253.                                         }
     
254.                                    }
     
255. 
     
256. 
     
257. /////////////////////////////////////////////////////////////////////////////////////
     
258. 
     
259.   }else digitalWrite(CLK, LOW);
     
260. 
     
261. 
     
262. 
     
263. }
     
264. 
     
265. 
     

复制代码

囧囧-科技大神粉

待修改的半成品

1. // EN+,脱机，高电平有效
   
2. // CW+,方向
   
3. // CLK+,频率（转速）
   
4. int EN=10;
   
5. int CW=11;
   
6. int CLK=12;
   
7. 
   
8. //步进电机控制器的细分数1、2、8、16（整、半、1/8、1/16）、整步用loop的方式是不行的，脉冲周期太短
   
9. int xifen=2;
   
10. 
    
11. //10步距角
    
12. int bujujiao=18;
    
13. //100度所需的色脉冲数,把度数放大，可以极大的提高控制精度，
    
14. int dumaichong100;
    
15. 
    
16. //脉冲的占空比为1/maichongzhankongbi
    
17. int maichongzhankongbi=4;
    
18. 
    
19. ////////////////////////////////////////////
    
20. 
    
21. int tempint;//打杂的中间数
    
22. 
    
23. int yunxingmoshi;//运行模式
    
24. int moshijsq=0;//模式计数器
    
25. boolean fangxiang=0;//电机转动方向标识
    
26. int fanzhuanfazhi=0;//反转阀值
    
27. 
    
28. float quanshuzy;//圈数增益（量）每秒，作为感官等额衰减的依据
    
29. int tempint2;//打杂的中间数2，专注记录，maichongjiange的变化
    
30. 
    
31. int maichongjsq=0;//脉冲计数器
    
32. 
    
33. int loopjsq=0;
    
34. unsigned long loopjsq2=0;
    
35. 
    
36. 
    
37. float zhuansunow=0;
    
38. float zhuansuWill=0;
    
39. 
    
40. boolean suduok=0;
    
41. boolean suduok2=0;
    
42. 
    
43. int tuoshijian;//拖时间，每增加1，则周期增加 基数×占空比
    
44. 
    
45. unsigned long time0=millis();
    
46. 
    
47. unsigned long time1=micros();//电机CLK
    
48. 
    
49. unsigned long time3=millis();//防止因音频变化而过快的改变电机的运行状态
    
50. 
    
51. 
    
52. void setup(){
    
53. 
    
54. Serial.begin(9600);
    
55. 
    
56. pinMode(EN, OUTPUT);// EN+,脱机，高电平有效
    
57. pinMode(CW, OUTPUT);// CW+,方向
    
58. pinMode(CLK, OUTPUT);// CLK+,频率（转速）
    
59. 
    
60. digitalWrite(EN, HIGH);//电机默认脱机
    
61. digitalWrite(CW, LOW);//
    
62. digitalWrite(CLK, LOW);
    
63. 
    
64. for(int col=2;col<10;col++)pinMode(col, INPUT_PULLUP);
    
65. 
    
66. dumaichong100=xifen*1000/bujujiao; //走100度所需脉冲数5555(1)        \        111(2)        \        444(8)        \        888(16)
    
67. 
    
68. }
    
69. 
    
70. 
    
71. 
    
72. 
    
73. void loop(){
    
74. 
    
75. 
    
76.   //获得可达到的最高理论转速，半步的情况下大概6转/秒,10ms测速一次
    
77. 
    
78. loopjsq++;
    
79. 
    
80.   if (millis() - time0 > 10){
    
81.    //此刻的loopjsq本质就是loop的运行次数，因为电机控制脉冲是以一次loop为基础的
    
82.    //转速 转/s = 有效脉冲数/细分/200
    
83.    
    
84.    /*
    
85.        表达方式无效 zhuansunow=loopjsq/(maichongzhankongbi*xifen*200);
    
86.                
    
87.                 328p扯淡的故事～～～
    
88.                 其中， zhuansunow为float，其他为int
    
89. 
    
90.                 tempint=maichongzhankongbi*xifen*200;
    
91.                 zhuansunow=loopjsq/tempint;
    
92.                 计算错误！！
    
93. 
    
94.                 zhuansunow=maichongzhankongbi*xifen*200;
    
95.                 zhuansunow=loopjsq/ zhuansunow;
    
96.                 计算正确
    
97.    */
    
98. 
    
99. zhuansunow=maichongzhankongbi*xifen*2;
    
100. zhuansunow=loopjsq/zhuansunow; //计算出每秒圈速
     
101. 
     
102.    
     
103. 
     
104. 
     
105. //引入布尔量，证明这个速度是可用的
     
106.    suduok=1;
     
107.    suduok2=1;
     
108.    
     
109.    
     
110.    loopjsq=0;
     
111. 
     
112.    
     
113.    time0=millis();
     
114.   }
     
115. 
     
116. 
     
117. 
     
118. //串口调速
     
119. chuankoutiaosu();
     
120. 
     
121. 
     
122. 
     
123. //音频调速
     
124. yinpintiaosu();
     
125.          
     
126.          
     
127. //速度衰减
     
128.   sudushuaijian();
     
129. 
     
130.   
     
131.   
     
132.   //速度的调节
     
133.    
     
134. 
     
135. 
     
136. if(suduok){
     
137.          suduok=0;
     
138. 
     
139.         if(zhuansuWill<zhuansunow)tuoshijian++;
     
140.         else if(tuoshijian>1)tuoshijian--;
     
141. 
     
142. }
     
143. 
     
144. 
     
145.   
     
146. 
     
147. 
     
148.   for(int col=1;col<tuoshijian;col++)delayMicroseconds(10);
     
149. 
     
150.   
     
151.   
     
152. //在脉冲频率无变化的时候驱动电机正常运行
     
153. maichongqudong();
     
154. 
     
155. 
     
156. 
     
157. 
     
158. 
     
159. 
     
160. }
     
161. 
     
162. 
     
163. 
     
164. void maichongqudong()//脉冲驱动
     
165. {
     
166. 
     
167.    maichongjsq++;//每过一个“脉冲间隔”时间段，则“脉冲计数器”自增1
     
168.         maichongjsq=maichongjsq%maichongzhankongbi;//对“脉冲计数器”取模，这个取摸结果实质就是对占空比的调节（占空比为1/模），以4为例，则“脉冲计数器”的变化为：0——1——2——3——0
     
169. 
     
170.         if(maichongjsq==0){
     
171.    
     
172.    digitalWrite(CLK, HIGH);//输出控制步进电机的电平
     
173.    
     
174. ///////////////////////////////////////////////////////////////////////////////////
     
175.     //H模式
     
176.         if(yunxingmoshi==1){
     
177.          //对于脉冲数的计数
     
178.         if(fangxiang)moshijsq++;
     
179.         else moshijsq--;
     
180. 
     
181.         //反转阀值折算为脉冲数进行反转
     
182.         tempint=fanzhuanfazhi*dumaichong100/100; // 需要度数*100度所需周期数
     
183.    
     
184.         if(moshijsq<-tempint || moshijsq>tempint){ //达到既定周期后反向
     
185.          fangxiang=!fangxiang;
     
186.          digitalWrite(CW, fangxiang);
     
187.      }
     
188.        }
     
189. 
     
190. 
     
191. /////////////////////////////////////////////////////////////////////////////////////
     
192. 
     
193.   }else digitalWrite(CLK, LOW);
     
194. 
     
195. 
     
196. 
     
197. }
     
198. 
     
199. 
     
200. void sudushuaijian(){
     
201.        
     
202.        
     
203.         //核心部分，转速的衰减
     
204. //此处用计数器代替时间
     
205. //设每转2圈减速一次
     
206. //理论上maichongzhankongbi*200*xifen =1圈 ,25%占空比、16细分，一圈为12800脉冲
     
207. //换言之 loopjsq2 为int时，占空比应该大于10%，改为unsigned long后就比较随意了
     
208. loopjsq2++;
     
209.         if (loopjsq2 > maichongzhankongbi*400*xifen){
     
210. 
     
211.                         loopjsq2=0;
     
212.                         Serial.print(zhuansuWill);
     
213.                         Serial.print("zhuansuWill/zhuansunow=");
     
214.                         Serial.println(zhuansunow);
     
215.          
     
216.                  
     
217.                         if(zhuansunow>0.5)zhuansuWill = zhuansuWill*0.95;
     
218.                         else zhuansuWill=0.5;
     
219. 
     
220. 
     
221.                         if(yunxingmoshi==1 && fanzhuanfazhi>10)fanzhuanfazhi=fanzhuanfazhi*0.8;//H模式下，同转速，每次衰减20%
     
222.    
     
223.       }
     
224.           
     
225.           
     
226.           
     
227.        
     
228.        
     
229. }
     
230. 
     
231. 
     
232. void yinpintiaosu(){
     
233.        
     
234.   //阻塞区内不做判断，最粗暴，完善的方法是，阻塞区内低值无效，高值有效
     
235. 
     
236.         for(int col=9;col>1;col--){
     
237. 
     
238.                 tempint= digitalRead(col);
     
239.                
     
240.          if(!tempint){ //低电平有效
     
241.                
     
242.                 // Serial.print("Max:"); //实际情况是其发送非常耗时，直接影响了步进电机的运行
     
243.                 // Serial.println(col);
     
244.                                 //对于速度增加的定义，鉴于其返回值有9、8····2端口值，先粗暴一把吧，直接按声压，而非实际分贝分类
     
245.                                // tempint2 = xifen2/(1.75+3.25*(col-1)/8);//在变化有效的情况下，maichongjiange的值得
     
246.           //实际人耳的分类，与电压、耳机灵敏度有关
     
247.           //现在以100db/mw灵敏度的耳机进行分类
     
248.           //目前实测，2个LM339的，8个基准脚的电压与接口、分贝对于关系为
     
249.           /*
     
250.         IO        2        \        3        \        4        \        5        \        6        \        7        \        8        \        9
     
251.         基准mV        6.5        \        12.9\        19.5\        26.1\        33        \        39.8\        46.2\        53.1
     
252.       32欧对应db        41.2\        47.1\        50.7\        53.2\        55.3\        56.9\        58.2\        59.4
     
253.       16欧对应db        44.2\        50.1\        53.7\        56.2\        58.3\        59.9\        61.2\        62.4
     
254. 
     
255.      
     
256.         可见
     
257.         1、耳机内阻减小虽然会导致功率翻倍，但分贝数不过变化3
     
258.         2、坑爹啊，基准值取得太高，导致范围曲在了41-59db，所需音量太大（电脑音量输出50%以上），且范围窄（小于提速无效，大于衰减无效）
     
259.         3、如果在32欧内阻下测量，需要细分到2mV（31db）、3mV（34db）、4mv（36.9db），328p分辨率不足，LM339的10mv分辨率更不足，需要放大
     
260.          
     
261.           */
     
262.       
     
263.    
     
264.       
     
265.                                 //仅当新值低于现值（周期短，频率高），此变化才是有效的
     
266.                                                                
     
267.                 float zhuansuWill2 = 0.5*col+0.5;
     
268.                  
     
269.         if(zhuansuWill2>zhuansuWill){
     
270.    
     
271.                         zhuansuWill = zhuansuWill2;
     
272.    
     
273.                         if(yunxingmoshi==1)fanzhuanfazhi=5*col;//反转阀值度数的确定，取端口值的5倍数
     
274.                 }
     
275. 
     
276. 
     
277. 
     
278.       
     
279.                 col=0;//跳出循环
     
280.          }
     
281.         }
     
282.        
     
283.        
     
284. }
     
285. 
     
286. 
     
287. void chuankoutiaosu(){
     
288.        
     
289.          //串口调速
     
290.      while (Serial.available() > 0) {
     
291. 
     
292.     //丧心病狂的单字节控制，0延迟，纯ASCII分拆
     
293.         //定义1 0-9表示转速，每一个表示10%
     
294.         //定义2 A正转、B反转
     
295.         //定义3 C联机、D脱机
     
296. 
     
297.    tempint=Serial.read();
     
298. 
     
299.    //调速度
     
300.    if(tempint>47 && tempint< 58) zhuansuWill = 0.5*(tempint-47);//48——58（0.5——5）
     
301.    //调方向 A、B
     
302.    else if(tempint==65){
     
303.     digitalWrite(CW, 0);
     
304.     fangxiang=0;
     
305.    }
     
306.    else if(tempint==66){
     
307.     digitalWrite(CW, 1);
     
308.     fangxiang=1;
     
309.    }
     
310.     //联机、脱机 C、D
     
311.    else if(tempint==67)digitalWrite(EN, 0);
     
312.    else if(tempint==68)digitalWrite(EN, 1);
     
313. 
     
314. //E 减速   F 加速
     
315.    else if(tempint==69){
     
316.     zhuansuWill = zhuansuWill*0.95;
     
317. 
     
318.    }
     
319.    else if(tempint==70){
     
320.     zhuansuWill = zhuansuWill*1.05;
     
321. 
     
322.    }
     
323.    
     
324.    //模式G 转动
     
325.    else if(tempint==71)yunxingmoshi=0;
     
326.    //模式H 摇摆
     
327.    else if(tempint==72)yunxingmoshi=1;
     
328. 
     
329.    else tempint=0;
     
330.    
     
331.    
     
332. 
     
333. 
     
334.   Serial.println(zhuansunow);
     
335. 
     
336. 
     
337. }
     
338.        
     
339. }
     
340. 
     
341. 
     
342. 
     
343. 
     
344. 
     

复制代码