设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › Arduino › 4通道示波器及Arduino信号发生代码
返回列表 发新帖
查看: 1995|回复: 0
收起左侧

4通道示波器及Arduino信号发生代码

[复制链接]
ID:426684 发表于 2019-2-5 15:34 | 显示全部楼层 |阅读模式
原始地址 (自行替换) www点instructables点com/id/Oscilloscope-Arduino-Processing/
[1] Arduino 上 A0 A1 A2 A3 为信号输出口
[2] 示波器是用 Processing 软件编写的

sbq.JPG 162020l6i2z5dljy67t277.jpg

Arduino 信号发生代码(略做修改):

  1. #define versao "v1.5"
  2. #include <TimerOne.h>
  3. const unsigned char PS_16 = (1 << ADPS2);
  4. const unsigned char PS_32 = (1 << ADPS2) | (1 << ADPS0);
  5. const unsigned char PS_64 = (1 << ADPS2) | (1 << ADPS1);
  6. const unsigned char PS_128 = (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
  7. boolean  pwmOn=true;
  8. unsigned long pwmP=20000; //Periodo 20000us=20ms=0.02s => 50Hz
  9. byte pwmPon=25; // % do pwmP em HIGH
  10. int vb[400]; // (100*4=400) buffer stores the measure values of all channels
  11. int chi[]={0,100,200,300}; // channel init position on buffer vb[]
  12. int chq=4; // how many channels are ON
  13. int q=100; // quantidade de leituras
  14. int qmax=100; // qtd maxima permitida para q
  15. int vtrigger=0; // tensao de trigger
  16. boolean Ch[]={true,true,true,true}; // ativa/desativa canais
  17. unsigned int dt=4; // 100us a 1000us(1ms) a 3000ms(3s)
  18. char unidade='m'; // unidade: m=milisegundo, u=microsegundo
  19. boolean varias=false; // v = varias
  20. boolean uma=false;    // u = uma
  21. boolean fluxo=false; // f = fluxo de dados (envia cada leitura sem guardar na memoria)
  22. unsigned long dtReal, tIni, tFim; // contador de final de tempo para o fluxo
  23. char canalTrigger='x'; // de '0','1','2','3' (canal do trigger), 'x'=não tem trigger


  26. //--------------- Ler Resistor/Capacitor ---------
  27. boolean lerRC=false;
  28. #define pinV 5
  29. #define pinA 10 // pino A 10 multiplex
  30. #define pinB 9 // pino B 9 multiplex
  31. byte entrada=0;
  32. int vi, vf, v;
  33. unsigned long dtRC=0;
  34. char unidadeRC=' ';
  35. boolean debug=true;

  37. void setup() {
  38.   ADCSRA &= ~PS_128;  //limpa configuração da biblioteca do arduino
  39.   ADCSRA |= PS_16; // 16 prescaler
  40.   pinMode(10,OUTPUT);
  41.   Timer1.initialize(pwmP); //100000us=100ms=>10Hz
  42.   Timer1.pwm(9,map(pwmPon,0,100,0,1023)); //pwm no pino9 com 25% duty cycle
  43.   Timer1.attachInterrupt(callback); //attaches callback() como timer overflow interrupt
  44.   Serial.begin(9600);
  45.   //Serial.begin(115200);
  46.   //Serial.begin(250000);
  47.   Serial.println();
  48.   Serial.print(">init="); Serial.println(versao);
  49.   pinMode(pinA,OUTPUT);
  50.   pinMode(pinB,OUTPUT);
  51.   selecionar(0);
  52. }

  54. void callback(){
  55.   digitalWrite(10,digitalRead(10)^1); // ^1 = xor (0->1, 1->0)
  56. }

  58. void loop() {
  59.    lerSerial();
  60.    if (varias) {
  61.       lerEnviar();
  62.    } else if (uma) {
  63.       if (canalTrigger=='x'){
  64.         lerEnviar();
  65.         uma=false;
  66.       } else {
  67.         if (trigger()){
  68.           lerEnviar();
  69.           uma=false;
  70.         }
  71.       }
  72.    } else if (fluxo) {
  73.       lerFluxo();
  74.    }
  75.    if (lerRC){
  76.      if (millis()>=dtRC){
  77.        lerResistorCapacitor();
  78.        dtRC=millis()+3000;
  79.      }
  80.    }
  81. }

  83. void lerSerial(){
  84.   int k;
  85.   float kf;
  86.   char c, c2;
  87.   if (Serial.available()>0){
  88.     c=Serial.read();
  89.     switch (c){
  90.        case 'h': // enviar help pela serial
  91.           printHelp();
  92.           break;
  93.        case 'd': //alterar o valor de dt (us/ms)
  94.           k=Serial.parseInt(); // como e inteiro então vai de 0 a 32767 (parseint limita 16bits)
  95.           if (k>=1 && k<=30000) {//28/08/15 deve ser dtmin=400us(3canais) dtmax=30000
  96.              dt=k;
  97.           }
  98.           c=Serial.read();
  99.           if (c=='u' || c=='m'){
  100.             unidade=c;
  101.           } else { // sem unidade é segundo, então converter para mili (x1000)m
  102.             unidade='m';
  103.             dt*=1000;
  104.           }
  105. //          Serial.print("=> dt="); Serial.print(dt); Serial.print(unidade); Serial.println("s");
  106.           break;
  107.        case 'q': // alterar valor do q.(ponto no final) (quantidade de leituras)
  108.           k=Serial.parseInt(); // inteiro de 0 a 32767
  109.           c=Serial.read(); // para ir mais rápido colocar um . no final ex: q150.
  110.           if (k>=1 && k<=qmax) {
  111.              q=k;
  112.           }
  113.           //calcBuffer(); //não precisa pois será usado o qmax
  114.           Serial.print("=> q="); Serial.println(q);
  115.           break;
  116.        case 'c': //cnm : n=0-3, m=(o)ativa/(x)desativa canal n exemplo:  c0x,  c2o
  117.           delay(100);
  118.           c=Serial.read();
  119.           delay(100);
  120.           c2=Serial.read();
  121.           if (c>='0' && c<='3'){
  122.              if (c2=='o'){
  123.                 Ch[c-'0']=true;
  124.              }else if (c2=='x'){
  125.                 Ch[c-'0']=false;
  126.              }
  127.              // recalcular o buffer para cada canal e colocar o indice
  128.              // inicial para cada canal
  129.              //Serial.println("entrar calcBuffer");
  130.              calcBuffer();
  131.              //Serial.println("saiu calcBuffer");
  132. /*            Serial.print("=> Canais: ");
  133.               for (k=0; k<3;k++){
  134.                 Serial.print("Ch"); Serial.print(k); Serial.print("="); Serial.print(Ch[k]);
  135.               }
  136.               Serial.println();
  137. */              
  138.             }  
  139.           break;
  140.        case 't': // trigger: t(canal)
  141.                  // trigger:  t0, t1, t2, t3
  142.                  //           tx   desligado
  143.                  //           tv512.  valor da tensão 0-1024 (5v)
  144.         delay(100);
  145.         c=Serial.read();
  146.         if ((c>='0' && c<='3') || c=='x'){
  147.            canalTrigger=c;      
  148.         } else if (c=='v'){
  149.           k=Serial.parseInt();
  150.           c=Serial.read();
  151.           if (k>=0 && k<=1024) {
  152.             vtrigger=k;
  153.           }
  154.         }

  156. //        Serial.print("=> canalTrigger="); Serial.println(canalTrigger);
  157.         break;
  158.        case '?':
  159.           printConfig();
  160.           break;
  161.         case '1': // enviar Uma Amostra (q leituras)
  162.           if (!uma) uma=true;
  163.           if (uma){
  164.              varias=false;
  165.              fluxo=false;
  166.           }
  167. //          Serial.print("=> uma="); Serial.println(uma);
  168.           break;
  169.         case 'v': // o(on)/x(off) - enviar Varias Amostras (q leituras cada)
  170.            delay(100);
  171.            c=Serial.read();
  172.            if (c=='o') {
  173.               varias=true;
  174.            } else {
  175.               varias=false;
  176.            }
  177.           if (varias){
  178.              uma=false;
  179.              fluxo=false;
  180.           }
  181. //          Serial.print("=> varias="); Serial.println(varias);
  182.           break;
  183.         case 'f': // o(on)/x(off) - enviar Fluxo (ler e enviar - nao armazenar)
  184.            delay(100);
  185.            c=Serial.read();
  186.            if (c=='o') {
  187.               fluxo=true;
  188.            } else {
  189.               fluxo=false;
  190.            }
  191.           if (fluxo){
  192.              varias=false;
  193.              uma=false;
  194.              if (unidade=='u'){ // microsegundo
  195.                tIni=micros(); tFim=tIni+dt;
  196.              } else{ // milisegundo
  197.                tIni=millis(); tFim=tIni+dt;
  198.              }
  199.           }
  200. //          Serial.print("=> fluxo="); Serial.println(fluxo);
  201.           break;
  202.          case 'r': // (on/off) - enviar valor lido do Resistor em A5
  203.            delay(100);
  204.            c=Serial.read();
  205.            if (c=='o') {
  206.               lerRC=true;
  207.            } else {
  208.               lerRC=false;
  209.            }
  210. //           Serial.print("=> lerRC="); Serial.println(lerRC);
  211.            dtRC=0;
  212.            break;
  213.          case 's': // Sinal: Ligar/desligar Gerador de Sinal
  214.           delay(100);
  215.           c=Serial.read();
  216.           if (c=='o'){
  217.             Timer1.restart(); // zera o contador
  218.             Timer1.start(); //inicio
  219. //            Serial.println("Timer1 restart/start");
  220.           }else{
  221.             Timer1.stop();
  222. //            Serial.println("Timer1.stop()");
  223.           }
  224.           break;
  225.          case 'p': // Sinal: alterar Período ex: p100m p343u
  226.           kf=Serial.parseFloat();
  227.           if (kf>0){
  228.             c=Serial.read(); // ler unidade e converter para micro
  229. //            Serial.print(">>kf="); Serial.print(kf); Serial.print(" c="); Serial.println(c);
  230.             switch (c){
  231.               case 'u': //já está em micro (u)
  232.                 pwmP=long(kf);
  233.                 break;
  234.               case 'm': // está em mili (m) então converter para micro (u)
  235.                 pwmP=long(kf*1000.0);
  236. //                Serial.print("kf="); Serial.print(kf); Serial.print("m"); Serial.print(" pwmP=kf*1000="); Serial.println(pwmP);
  237.                 break;
  238.               case ' ': // está em segundo ( ) então converter para micro (u)
  239.                 pwmP=long(kf*1000000.0);
  240.                 break;
  241.                default: // se veio caracter desconhecido faço o pwmP=1s
  242.                 pwmP=1000000l; // coloquei L no final do 100000 para dizer que é long
  243. //                Serial.print("=> erro unidade pwmP, usando padrao(us)="); Serial.println(1000000);
  244.                 break;
  245.             }
  246.             Timer1.setPeriod(pwmP);
  247.             Timer1.setPwmDuty(9,map(pwmPon,0,100,0,1023));
  248. //            Serial.print("=> setPeriod="); Serial.println(pwmP);
  249.           }
  250.           break;
  251.          case 'o': // Sinal: alterar tempo em ON ex: o25% o50%
  252.           k=int(Serial.parseFloat());
  253.           c=Serial.read(); // só ler a % e desprezar (faz o parseInt ficar mais rapido
  254.           if (k>=0 && k<=100){
  255.             pwmPon=k;
  256.             Timer1.setPwmDuty(9,map(pwmPon,0,100,0,1023));
  257. //            Serial.print("=> pwm on="); Serial.print(k); Serial.println("%");         
  258.           }
  259.           break;
  260.          default:
  261.            Serial.print("erro c="); Serial.println(c,HEX);
  262.     }
  263.   }
  264. }

  266. void calcBuffer(){
  267.   //Serial.println("entrou calcBuffer");
  268.   chq=0;
  269.   // conta a quantidade de canais ativos
  270.   for (int k=0;k<4;k++){
  271.     if (Ch[k]) {chq+=1;}
  272.   }
  273.   // calc size of each channel
  274.   switch (chq){
  275.     case 0:
  276.       qmax=0;
  277.       break;
  278.     case 1:
  279.       qmax=400;
  280.       break;
  281.     case 2:
  282.       qmax=200;
  283.       break;
  284.     case 3:
  285.       qmax=130;
  286.       break;
  287.     case 4:
  288.       qmax=100;
  289.       break;
  290.   }
  291.   /*
  292.   if (chq<=0) {
  293.     qmax=0;
  294.   } else {
  295.     qmax=408/chq; // chq-qmax; 4-102; 3-136; 2-204; 1-408
  296.   }
  297. */
  298.   if (q>qmax) {
  299.     q=qmax;
  300.   }
  301.   //Serial.print("q=408/chq=");Serial.print("408/");Serial.print(chq);Serial.print("=");Serial.println(q);
  302.   // qtdCanais-qmax (chq-qmax) (4-100) (3-130) (2-200) (1-400)
  303.   int chInit=0;
  304.   for (int k=0; k<4; k++){
  305.     if (Ch[k]) {
  306.       chi[k]=chInit;
  307.       chInit+=qmax;
  308.     }
  309.   }

  311. // Serial.print("chq="); Serial.print(chq); Serial.print(" q="); Serial.print(q); Serial.print(" qmax="); Serial.println(qmax);
  312. //  for (int k=0; k<4; k++){
  313. //    Serial.print("k=");Serial.print(k); Serial.print(" chi[k]="); Serial.println(chi[k]);
  314. // }

  316. }

  318. void printHelp(){
  319.    Serial.println("-----------------------");
  320.    Serial.print("! BegOscopio "); Serial.print(versao); Serial.println(" - [email]rogerio.bego@hotmail.com[/email] !");
  321.    Serial.println("-----------------------");
  322. /*
  323.    Serial.println("----------- help ---------------------");
  324.    Serial.println(" h    : help");
  325.    Serial.println(" ?    : exibir as configuracoes atuais");
  326.    Serial.println(" -------- controle da amostragem ------");
  327.    Serial.println(" d___ : d[1-3000][un] - ex: d100m, d200u - dt = intervalo de tempo (us/ms) entre as leituras");
  328.    Serial.println(" q___ : q[1-100]. - qtd de leituras");
  329.    Serial.println(" cn_  : (o)ativa,(x)desativa canal: ex:  c2o (ativar Ch2), c0x (desativar Ch0)");
  330.    Serial.println(" t_   : 0,1,2,3(canal),x(off)  ");
  331.    Serial.println(" tv__ : tv512.  valor da tensao 0-1024 (0-5v)");
  332.    Serial.println(" -------- envio das amostras ---------");
  333.    Serial.println(" 1    : enviar uma amostra");
  334.    Serial.println(" v_   : o(on),x(off) enviar varias amostras");
  335.    Serial.println(" f_   : o(on),x(off) enviar fluxo de dados");
  336.    Serial.println("    obs:  1, v, f sao mutuamente excludentes");
  337.    Serial.println(" -------- leitura de Resistor ou Capacitor ----");
  338.    Serial.println(" r_   : o(on),x(off) ler Resistor ou Capacitor");
  339.    Serial.println(" -------- Gerador de Sinal pwm ---------");
  340.    Serial.println(" s_   : o(on),x(off) ativa Ger.Sinal (pwm na porta 9) (porta 10 indica 2*T)");
  341.    Serial.println(" p_   : p[valor][unidade] periodo do sinal de 100u a 8s");
  342.    Serial.println(" o_   : o[0-100][%] Ton em porcentagem");
  343.    Serial.println("----------------------------------------");
  344.    */
  345. }



  349. void printConfig(){
  350.    Serial.println("------ configuracoes -------");
  351.    Serial.print(">? q="); Serial.println(q);
  352.    Serial.print(">? qmax="); Serial.println(qmax);
  353.    Serial.print(">? dt="); Serial.print(dt); Serial.print(unidade); Serial.println("s");
  354.    float t=(float)q * (float)dt;
  355.    Serial.print(" -> T=(q*dt)= "); Serial.print(t); Serial.print(unidade); Serial.println("s ");
  356.    Serial.print(">? Canais: ");
  357.    for (int k=0; k<4; k++){
  358.       Serial.print("  Ch"); Serial.print(k); Serial.print("=");
  359.       if (Ch[k]) {
  360.         Serial.print("o");     
  361.       } else {
  362.         Serial.print("x");
  363.       }
  364.    }
  365.    Serial.println();
  366.    Serial.print(">? canalTrigger="); Serial.println(canalTrigger);
  367.    Serial.print(">? uma="); Serial.println(uma);
  368.    Serial.print(">? varias="); Serial.println(varias);
  369.    Serial.print(">? fluxo="); Serial.println(fluxo);
  370.    Serial.print(">? lerRC="); Serial.println(lerRC);
  371.    Serial.print(">? pwmOn="); Serial.println(pwmOn);
  372.    Serial.print(">? pwmP="); Serial.print(pwmP); Serial.println("us");
  373.    Serial.print(">? pwmPon="); Serial.print(pwmPon); Serial.println("%");
  374. }


  377. unsigned long microsOuMillis(){
  378.    if (unidade=='u'){
  379.       return micros();
  380.    } else {
  381.       return millis();
  382.    }
  383. }

  385. //-- procurar tensão maior que zero no canalTrigger ----
  386. //-- se UMA=true então fica aguardando indefinitivamente
  387. //-- se UMA=false então fica aguardando até o tempo tFIM (q*dt)
  388. boolean trigger(){ // a variavel canalTrigger indica qual canal fará o trigger: 0,1,2 ou 3
  389.   unsigned long tFim; // contador do tempo Final
  390.   int v1=0,v2=0;
  391.   //int c1=0, c2=0;
  392.   boolean achou=false;
  393.     tFim=microsOuMillis()+q*dt;
  394.     // dispara na subida do valor vtrigger+10
  395.     //fica lendo a tensão enquanto for maior que vtrigger
  396.     //   E tempo menor que tFim
  397.     do{
  398.       v1=analogRead(canalTrigger-'0');
  399.       //c1++;
  400.     }while (v1>vtrigger && microsOuMillis()<tFim);
  401.   //  while (v1=analogRead(canalTrigger-'0')>0 && microsOuMillis()<tFim){c1++;}
  402.     if (v1<=vtrigger){
  403.       tFim=microsOuMillis()+q*dt;
  404.       //fica lendo a tensão enquanto for menor ou igual a 10+vtrigger
  405.       // E tempo menor que tFim
  406.       do{
  407.         v2=analogRead(canalTrigger-'0');
  408.         //c2++;
  409.       }while(v2<=10+vtrigger && microsOuMillis()<tFim);
  410.       //while (v2=analogRead(canalTrigger-'0')<=0 && microsOuMillis()<tFim){c2++;}
  411.       if (v2>10+vtrigger){
  412.         achou=true;
  413.       }
  414.       //Serial.print("v1="); Serial.print(v1); Serial.print(" v2=");Serial.println(v2);
  415.       //Serial.print("c1=");Serial.print(c1);Serial.print(" c2=");Serial.println(c2);
  416.     }
  417.     return achou;
  418. }


  421. void lerEnviar(){

  423. /*  
  424.   // enviar quais canais serao enviados. ex: >ch=1<\t>3<\t>
  425.   Serial.print(">chq="); Serial.print(chq); Serial.print("\t");
  426.   for (int k=0; k<4; k++){
  427.     if (Ch[k]){Serial.print(k); Serial.print("\t");}   
  428.   }
  429.   Serial.println("");

  431.   //enviar os valores dos canais
  432.   for (int k=0; k<q; k++){
  433.     Serial.print(">v="); Serial.print(k); Serial.print("\t");
  434.     if (Ch[0]) {Serial.print(chi[0]+k); Serial.print("\t");}
  435.     if (Ch[1]) {Serial.print(chi[1]+k); Serial.print("\t");}
  436.     if (Ch[2]) {Serial.print(chi[2]+k); Serial.print("\t");}
  437.     if (Ch[3]) {Serial.print(chi[3]+k); Serial.print("\t");}
  438.     Serial.println("");
  439.   }


  442.   return;

  444.   */


  447.   unsigned long tFim; // contador do tempo Final
  448.   unsigned long tTotalReal; // tempo Total da leitura dos valores.
  449.     if (canalTrigger>='0' && canalTrigger<='3'){
  450.       //Serial.print("canalTrigger=");Serial.println(canalTrigger);
  451.       Serial.print("trigger="); Serial.println(trigger());
  452.      }
  453.     tTotalReal=microsOuMillis();

  455.     for (int k=0; k<q; k++){
  456.       tFim=microsOuMillis()+dt;
  457. /*
  458.       if (Ch[0]) {v0[k]=analogRead(A0);}
  459.       if (Ch[1]) {v1[k]=analogRead(A1);}
  460.       if (Ch[2]) {v2[k]=analogRead(A2);}
  461.       if (Ch[3]) {v3[k]=analogRead(A3);}
  462. */

  464.       if (Ch[0]) {vb[chi[0]+k]=analogRead(A0);}
  465.       if (Ch[1]) {vb[chi[1]+k]=analogRead(A1);}
  466.       if (Ch[2]) {vb[chi[2]+k]=analogRead(A2);}
  467.       if (Ch[3]) {vb[chi[3]+k]=analogRead(A3);}
  468.       while (microsOuMillis()<tFim){}
  469.     }


  472.     tTotalReal=microsOuMillis()-tTotalReal; // total de tempo para ler todas as amostras
  473.     dtReal=tTotalReal/q; // calcular o tempo médio de cada leitura
  474.   Serial.println();
  475.   Serial.print(">q="); Serial.println(q);
  476.   Serial.print(">dt="); Serial.print(dt); Serial.print(unidade); Serial.println("s");
  477.   Serial.print(">dtReal="); Serial.print(dtReal); //  Serial.print(unidade); Serial.println("s");
  478.     if (unidade=='m'){
  479.       Serial.println("e-3");
  480.     }else if (unidade=='u'){
  481.       Serial.println("e-6");
  482.     }

  484.   // enviar quais canais serao enviados. ex: >ch=1<\t>3<\t>
  485.   Serial.print(">chq="); Serial.print(chq); Serial.print("\t");
  486.   for (int k=0; k<4; k++){
  487.     if (Ch[k]){Serial.print(k); Serial.print("\t");}   
  488.   }
  489.   Serial.println("");

  491.   //enviar os valores dos canais
  492.   for (int k=0; k<q; k++){
  493.     Serial.print(">v="); Serial.print(k); Serial.print("\t");
  494.     if (Ch[0]) {Serial.print(vb[chi[0]+k]); Serial.print("\t");}
  495.     if (Ch[1]) {Serial.print(vb[chi[1]+k]); Serial.print("\t");}
  496.     if (Ch[2]) {Serial.print(vb[chi[2]+k]); Serial.print("\t");}
  497.     if (Ch[3]) {Serial.print(vb[chi[3]+k]); Serial.print("\t");}
  498.     Serial.println("");

  500.   /*
  501.     if (Ch[0]) {Serial.print(chi[0]+k); Serial.print("\t");}
  502.     if (Ch[1]) {Serial.print(chi[1]+k); Serial.print("\t");}
  503.     if (Ch[2]) {Serial.print(chi[2]+k); Serial.print("\t");}
  504.     if (Ch[3]) {Serial.print(chi[3]+k); Serial.print("\t");}
  505.     Serial.println("");
  506.   */
  507.   }
  508. /* -- eliminado em 07/May/2017 - criei buffer dinamico  vb[408] --   
  509.   for (int k=0; k<q; k++){
  510.     Serial.print(">v=");
  511.     Serial.print(k); Serial.print("\t");
  512.     Serial.print(v0[k]); Serial.print("\t");
  513.     Serial.print(v1[k]); Serial.print("\t");
  514.     Serial.print(v2[k]); Serial.print("\t");
  515.     Serial.println(v3[k]);
  516.   }
  517.   */
  518.   Serial.print(">tTotalReal="); Serial.print(tTotalReal); //Serial.print(unidade); Serial.println("s");
  519.     if (unidade=='m'){
  520.       Serial.println("e-3");
  521.     }else if (unidade=='u'){
  522.       Serial.println("e-6");
  523.     }
  524. }

  526. void lerFluxo(){
  527.   int v0, v1, v2, v3; // guarda os valores das leituras
  528.   //byte v0, v1, v2, v3; // guarda os valores das leituras
  529.   boolean leu=false;
  530.     if (microsOuMillis()>=tFim){
  531.       dtReal=microsOuMillis()-tIni;
  532.       tIni=microsOuMillis(); tFim=tIni+dt;
  533.       if (Ch[0]) {v0=analogRead(A0);}
  534.       if (Ch[1]) {v1=analogRead(A1);}
  535.       if (Ch[2]) {v2=analogRead(A2);}
  536.       if (Ch[3]) {v3=analogRead(A3);}
  537.       //if (Ch[0]) {v0=analogRead(A0)/4;}
  538.       //if (Ch[1]) {v1=analogRead(A1)/4;}
  539.       //if (Ch[2]) {v2=analogRead(A2)/4;}
  540.       //if (Ch[3]) {v3=analogRead(A3)/4;}
  541.       leu=true;
  542.     }
  543.   if (leu){
  544.     Serial.print(">f=");
  545.     Serial.print("0"); Serial.print("\t");
  546.     Serial.print(dtReal);
  547.       if (unidade=='m'){
  548.         Serial.print("e-3");
  549.       }else if (unidade=='u'){
  550.         Serial.print("e-6");
  551.       }
  552.       Serial.print("\t");
  553.     if (Ch[0]) {Serial.print(v0);} else {Serial.print("0");} Serial.print("\t");
  554.     if (Ch[1]) {Serial.print(v1);} else {Serial.print("0");} Serial.print("\t");
  555.     if (Ch[2]) {Serial.print(v2);} else {Serial.print("0");} Serial.print("\t");
  556.     if (Ch[3]) {Serial.println(v3);} else {Serial.println("0");}
  557.   }
  558. }

  560. //=========== Rotinas para leitura de Resistor e Capacitor ===========

  562. void lerResistorCapacitor(){
  563.   descarregar();
  564.   lerEntrada(1);
  565.   if (vf-vi>=100) {// e' capacitor
  566.     calcCapacitor();
  567.   } else {
  568.     if (v<900) { // calcular valor do resistor
  569.       calcRx();
  570.     } else { // subir selecionar 2
  571.       // descarregar se for capacitor
  572.       descarregar();
  573.       lerEntrada(2);
  574.       if (vf-vi>=100) { // capacitor - escala 2
  575.         calcCapacitor();
  576.       } else { // resistor
  577.         if (v<900){ // calcular valor do resistor
  578.           calcRx();
  579.         } else { // subir selecionar 3 (nao consegue detectar capacitor corretamente)
  580.           lerEntrada(3);
  581.           if (v<900){
  582.             calcRx();
  583.           } else {
  584.             Serial.println(">rc=3\tColoque RC");
  585.           }
  586.         }
  587.       }
  588.     }
  589.   }
  590. }

  592. void calcCapacitor(){
  593.   float re[]={0.0,145.2,20692.9,1017847.5};
  594.   float cx=0;
  595.   descarregar();
  596.   selecionar(1);
  597.   dtRC=millis();
  598.   while (analogRead(pinV)<647){} // 647 = 63.2% Vcc => (nessa voltagem  t=rc)
  599.   dtRC=millis()-dtRC;
  600.   if (dtRC>=100) { // dentro da faixa Cx>1mF
  601.     cx=(float)dtRC/re[entrada];
  602.     unidadeRC='m';  //resultado em mF
  603.   } else { // fora da faixa, subir para escala 2
  604.     descarregar();
  605.     selecionar(2);
  606.     dtRC=millis();
  607.     while (analogRead(pinV)<647){}
  608.     dtRC=millis()-dtRC;
  609.     if (dtRC>=10) { // dentro da faixa
  610.       cx=(float)dtRC*1000.0/re[entrada];
  611.       unidadeRC='u'; // resultado em uF
  612.     } else { // fora da faixa, então subir escala
  613.       descarregar();
  614.       selecionar(3);
  615.       dtRC=millis();
  616.       while (analogRead(pinV)<647){}
  617.       dtRC=millis()-dtRC;
  618.       cx=(float)dtRC*1000000.0/re[entrada];
  619.       unidadeRC='n'; // resultado em nF
  620.     }
  621.   }
  622.   Serial.print(">c="); Serial.print(entrada); Serial.print("\t"); Serial.print(cx); Serial.print(" "); Serial.print(unidadeRC); Serial.println("F");
  623. }

  625. void lerEntrada(byte e){
  626.   selecionar(e);
  627.   dtRC=micros();
  628.   vi=analogRead(pinV);
  629.   v=0;
  630.   for (int k=0; k<10; k++){
  631.      v+=analogRead(pinV);
  632.   }
  633.   v/=10;
  634.   vf=analogRead(pinV);
  635.   dtRC=micros()-dtRC;
  636. }

  638. void descarregar(){
  639.   selecionar(0);
  640.   while (analogRead(pinV)>0){}
  641. }

  643. void calcRx(){
  644.   float re[]={0.0,145.2,20692.9,1017847.5};
  645.   float vcc[]={0,871.5,1026.3,1027.1};
  646.   float rx=0;
  647.   rx=re[entrada]*(float)v/(vcc[entrada]-(float)v);
  648.   Serial.print(">r="); Serial.print(entrada); Serial.print("\t");
  649.   switch (entrada) {
  650.      case 1:
  651.       if (rx>=1000){
  652.         rx/=1000;
  653.         Serial.print(rx); Serial.println(" Kohm");
  654.       } else {
  655.         Serial.print(rx); Serial.println(" ohm");
  656.       }
  657.       break;
  658.      case 2:
  659.       Serial.print(rx/1000); Serial.println(" Kohm");
  660.       break;
  661.      case 3:
  662.       Serial.print(rx/1000000); Serial.println(" Mohm");
  663.       break;
  664.   }
  665. }

  667. void selecionar(byte e){
  668.   entrada=e;
  669.   digitalWrite(pinA,bitRead(entrada,0));
  670.   digitalWrite(pinB,bitRead(entrada,1));
  671. }

  673. Processing示波器代码(部分修改):
  674. String versao="v1.0";
  675. PFont font;

  677. byte escLinear=0; // Dial com escala linear
  678. byte escLog=1;     // Dial com escala logarítimica (base 10)
  679. byte altMove=2; // mudar o valor ao arrastar o mouse "MouseDragged"
  680. byte altSolta=3; // mudar o valor ao soltar o botão do mouse "MouseReleased"
  681. boolean nInt=true; // n é inteiro (arredondar), ou decimal !nInt
  682. boolean fmt=true; // fmt=true="formatar",  !fmt=false="não formatar"
  683. boolean esperandoTrigger=false;
  684. int vTrigger=0; // valor do trigger (subindo) 0-1024 (0-5v)
  685. color cor[]={color(255, 0, 0), color(0, 255, 0), color(0, 0, 255), color(255,255,0)}; // canais: red,green,blue,yellow
  686. import processing.serial.*;
  687. PrintWriter output;
  688. boolean outputOpen=false;
  689. Botao save;
  690. int qSave=0;
  691. Serial port;
  692. Com com;
  693. Tela tela;
  694. CanalXYZ chXYZ;
  695. Botao resetEixos;
  696. Botao resetMedir;
  697. Canal canal[]=new Canal[4];
  698. //byte chq=4; // qtd de canais ativos
  699. Grupo grupo[]=new Grupo[3]; // usado para alterar v/div e ms/div simultaneamente em todos os canais usando SHIFT
  700. // painel para os controles de Amostragem
  701. Painel pnlAmostra; // painel
  702. Dial dt; // delta t (tempo de cada leitura)
  703. Dial q;  // quantidade de leituras
  704. Botao umaAmostra; // solicita uma Amostra
  705. Botao variasAmostras; // solicita várias Amostras
  706. Botao fluxoContinuo;  // entra com leitura a cada dt
  707. FmtNum tTotal; // tempo total da amostragem dt*q

  709. Botao demo[]=new Botao[3]; // botões para gerar sinais de demonstração
  710. float fase1, fase2, t1, t2; // fase dos DEMO //para noise(t) do demo
  711. CheckBox verPontos; // ver os pontos da amostragem
  712. CheckBox calcFreq; // detectar frequencia
  713. CheckBox grafDif; // (ver) mostrar gráfico Diferença (parecido com a derivada)

  715. //Dial ruido; // usado para melhorar a detecção da frequencia

  717. // painel para medir resistor/capacitor
  718. Painel pnlRC; // o valor é colocado em tex2 do CheckBox RC
  719. CheckBox RC; // ativa/desativa medidor de resistor/capacitor

  721. // painel para o Gerador de Sinal
  722. Painel pnlSinal;
  723. CheckBox sinal; // f e t são dependentes f=1/t, t=1/f
  724. Dial fSinal;    // f (frequencia) do Sinal (10kHz-0.125Hz)
  725. Dial tSinal;    // T (período) do Sinal (100us-8s)
  726. Dial tonSinal;  // tempo em ON (0-100%)

  728. // verificar se o tempo de leitura Real é igual ao desejado
  729. FmtNum tTotalReal, dtReal; // tempos reais de leitura enviados pelo Arduino
  730. boolean dtErro=false;
  731. float Q=45.0; //tamanho do quadrado na tela

  733. int chq=4; // qtd de canais selecionados (visiveis)
  734. //int qMax=102; // chq-qMax: 4-102, 3-136, 2-204, 1-408
  735. int ch[]={0,1,2,3}; // quais canais estão visiveis (ON)


  738. //temporarios
  739. int marg1, marg2; //margem temporaria para ajustar a posição dos objetos

  741. void setup() {
  742.   size(680, 700);
  743.   font = createFont("宋体.vlw",48);
  744.   textFont(font);
  745.   //size(800,700);
  746.   frameRate(10);
  747.   tela=new Tela(30+10, 60, 10*Q, 12*Q);  //horizontal 10divisoes , vertical 12divisoes
  748.   marg1=tela.x+tela.w+10;
  749.   marg2=marg1+200;
  750.   com=new Com(port, tela.x+tela.w-250, 5, 250, 55);
  751.      for (byte k=0; k<3; k++){ // deve estar antes do canal
  752.       grupo[k]=new Grupo();
  753.    }

  755.   resetEixos=new Botao("eixos",marg1+50,tela.y,45,20);
  756.   resetMedir=new Botao("medir",resetEixos.x+resetEixos.w+2,tela.y,45,20);

  758.   //demo & canais
  759.   for (byte k=0; k<4; k++) {
  760.     if (k<3) {demo[k]=new Botao(str(k+1), marg1+50+k*30, tela.y/2-10, 30, 20);}
  761.     canal[k]=new Canal(k, cor[k], marg1, tela.y+27+k*110, 143, 100); //h115
  762.   }
  763.    chXYZ=new CanalXYZ(color(255,0,255),marg1,canal[3].y+canal[3].h+10,143,80);
  764.   chXYZ.verCanais.clicado=true;

  766.   verPontos=new CheckBox("ver pontos", chXYZ.x, chXYZ.y+chXYZ.h+5, 15);
  767.   calcFreq=new CheckBox("detectar freq.", verPontos.x, verPontos.y+verPontos.h+5, 15);
  768.   grafDif=new CheckBox("ver",calcFreq.x+calcFreq.w,calcFreq.y,15);
  769.   save=new Botao("salvar datax.txt",calcFreq.x,calcFreq.y+calcFreq.h+5,150,20);
  770.   //medidor de resistor/capacitor
  771.   pnlRC=new Painel("", tela.x, tela.y+tela.h+10, 125, 40);
  772.   RC=new CheckBox("medir res./cap.", pnlRC.x, pnlRC.y, 15);
  773.   //Gerador de Sinais - agora só gera onda quadrada, depois vai gerar triangulo, denteDeSerra, e senidal
  774.   pnlSinal=new Painel("", pnlRC.x+pnlRC.w+10, pnlRC.y, 100, 85);
  775.   sinal=new CheckBox("Ger.Sinal", pnlSinal.x, pnlSinal.y, 15);
  776.   fSinal=new Dial(escLog, altSolta, !nInt, fmt, "f", "Hz", 50f, 125e-3f, 10e3f, pnlSinal.x+5, sinal.y+sinal.h+2, pnlSinal.w-10, 20);
  777.   tSinal=new Dial(escLog, altSolta, !nInt, fmt, "T", "s", 20e-3f, 100e-6f, 8f, fSinal.x, fSinal.y+fSinal.h+2, fSinal.w, fSinal.h);
  778.   tonSinal=new Dial(escLinear, altSolta, nInt, !fmt, "Ton", "%", 25f, 0f, 100f, tSinal.x, tSinal.y+tSinal.h+2, tSinal.w, tSinal.h);
  779.   // posicionamento da Amostragem
  780.   pnlAmostra=new Painel("Amostragem", pnlSinal.x+pnlSinal.w+10, pnlSinal.y, 200, 85);
  781.   dt=new Dial(escLog, altSolta, nInt, fmt, "dt", "s", 1e-3f, 10e-6f, 2f, pnlAmostra.x+5, pnlAmostra.y+20, 100, 20);
  782.   dtReal=new FmtNum(0,nInt,fmt);
  783.   q=new Dial(escLinear, altSolta, nInt, !fmt, "q", "", 100, 1, 100, dt.x+dt.w+5, dt.y, 60, 20);
  784.   tTotal=new FmtNum(dt.v.getV()*q.v.getV(), !nInt);
  785.   tTotalReal=new FmtNum(0,!nInt);
  786.   umaAmostra=new Botao("uma", dt.x, dt.y+dt.h+5, 50, 20);
  787.   variasAmostras=new Botao("varias", umaAmostra.x+umaAmostra.w+5, umaAmostra.y, umaAmostra.w, umaAmostra.h);
  788.   fluxoContinuo=new Botao("fluxo", variasAmostras.x+variasAmostras.w+5, variasAmostras.y, variasAmostras.w, variasAmostras.h);
  789. }

  791. void draw() {
  792.   //==== Construir a tela e mostrar os controles =========
  793.   background(100);
  794.   fill(0, 255, 255);
  795.   textAlign(LEFT, TOP);
  796.   textSize(18);
  797.   text("四通道示波器 "+versao, tela.x, 12);
  798.   fill(0);
  799.   textSize(12);
  800.   text("    DiscoverySoft.com", tela.x, tela.y-15);
  801.   tela.display();
  802.   textSize(15);
  803.   fill(0);
  804.   textAlign(RIGHT, CENTER);
  805.   text("演示", demo[0].x-5, demo[0].y+demo[0].h/2); //tela.x+tela.w+10,tela.y);
  806.   text("重置",resetEixos.x-5,resetEixos.y+resetEixos.h/2);
  807.    chXYZ.display();
  808.     for (byte k=0; k<4; k++) {
  809.     if (k<3){demo[k].display();}
  810.         canal[k].display();
  811.   }
  812.    verPontos.display();
  813.   calcFreq.display();
  814.   grafDif.display();
  815.   //ruido.display();
  816.   save.display();
  817.   com.display();
  818.   resetEixos.display();
  819.   resetMedir.display();

  821.   tTotal.setV(dt.v.getV()*q.v.getV());
  822.   pnlAmostra.tex2="("+tTotal.printV()+"s)";
  823.   pnlAmostra.display();
  824.   dt.display();
  825.   q.display();  
  826.   umaAmostra.display();
  827.   variasAmostras.display();
  828.   fluxoContinuo.display();
  829.   //== mostrar o dtReal, tTotalRea e o erro
  830.   textAlign(LEFT);
  831.   if (dtErro){ fill(255,0,0); } else {fill(0,20,0); }
  832.   String tex="Real: dt"+dtReal.printV()+"s";
  833.   if (fluxoContinuo.clicado==false){
  834.      tex+="  total"+tTotalReal.printV()+"s";
  835.   }
  836.   text(tex,pnlAmostra.x+5,pnlAmostra.y+pnlAmostra.h-2);
  837.   fill(0);
  838.   pnlRC.display();
  839.   RC.display();
  840.   pnlSinal.display();
  841.   sinal.display();
  842.   fSinal.display();
  843.   tSinal.display();
  844.   tonSinal.display();

  846.   //=== se DEMO estiver ativado, então, gerar os dados ===
  847.   if (demo[0].clicado){
  848.         float mf=second()/10; // de 10 em 10 segundos faz multiplos da frequencia mf*freq
  849.         for (int k=0; k<q.v.v; k++){
  850.            canal[0].buffer[k]=(int)(512.0*(1+sin(2.0*PI*fSinal.v.v*((float)k*dt.v.v))));
  851.            canal[1].buffer[k]=(int)(512.0*(1+sin(fase1+2.0*PI*tonSinal.v.v/10.0*fSinal.v.v*((float)k*dt.v.v))));
  852.            canal[2].buffer[k]=(canal[0].buffer[k]+canal[1].buffer[k])/2;
  853.            canal[3].buffer[k]=(int)(512.0*(1+sin(2.0*PI*fSinal.v.v*(k*dt.v.v)+sin(2*PI*mf*fSinal.v.v*(k*dt.v.v)))));
  854.         }
  855.            fase1+=2*PI/100;
  856.         canal[0].atualizou=true;
  857.         canal[1].atualizou=true;
  858.         canal[2].atualizou=true;
  859.         canal[3].atualizou=true;
  860.   } else if (demo[1].clicado){
  861.         float qmax=1/(fSinal.v.v*2*dt.v.v);
  862.         float qmin=qmax*tonSinal.v.v/100.0;
  863.         float qc=0.0;
  864.         float fator=0;
  865.         float vq=0;        
  866.         float f0=(fase1/(2.0*PI*fSinal.v.v*dt.v.v))%qmax;
  867.         float f1=((fase1+radians(120))/(2.0*PI*fSinal.v.v*dt.v.v))%qmax;
  868.         float f2=((fase1+radians(240))/(2.0*PI*fSinal.v.v*dt.v.v))%qmax;

  870.         for (int k=0; k<q.v.v; k++){
  871.            qc=k % qmax;
  872.            if (qc<qmin) fator=0; else fator=1.0;
  873.                t2=((float)k+f0) % qmax;
  874.            if (t2<qmin) vq=0; else vq=1.0;
  875.            canal[0].buffer[k]=(int)(vq*512.0*(sin(fase1+2.0*PI*fSinal.v.v*((float)k*dt.v.v))));
  876.            canal[3].buffer[k]=(int)(vq*1023.0);

  878.            t2=((float)k+f1)%qmax;
  879.            if (t2<qmin) vq=0; else vq=1.0;
  880.            canal[1].buffer[k]=(int)(vq*512.0*(sin(fase1+radians(120)+2.0*PI*fSinal.v.v*((float)k*dt.v.v))));

  882.            t2=((float)k+f2)%qmax;
  883.            if (t2<qmin) vq=0; else vq=1.0;
  884.            canal[2].buffer[k]=(int)(vq*512.0*(sin(fase1+radians(240)+2.0*PI*fSinal.v.v*((float)k*dt.v.v))));

  886.          }

  888.         canal[0].atualizou=true;
  889.         canal[1].atualizou=true;
  890.         canal[2].atualizou=true;
  891.         canal[3].atualizou=true;

  893.   } else if (demo[2].clicado){

  895.         float qmax=1.0/(2*dt.v.v*fSinal.v.v);
  896.         float qmin=qmax*tonSinal.v.v/100.0;
  897.         float qc=0.0;
  898.         float fator=0;
  899.         for (int k=0; k<q.v.v; k++){
  900.            qc=k % qmax;
  901.                   if (qc<qmin) fator=1; else fator=0;
  902.            canal[0].buffer[k]=(int)(fator*1023.0);
  903.            if (qc<qmin) {
  904.              canal[1].buffer[k]=(int)(512.0*(1.0-exp(-qc*100.0*dt.v.v)));
  905.            } else {
  906.              canal[1].buffer[k]=(int)(512.0*(exp(-(qc-qmin+1)*100.0*dt.v.v)));
  907.            }
  908.            canal[2].buffer[k]=(int)(512.0+512.0*(sin(radians(240)+2.0*PI*fSinal.v.v*((float)k*dt.v.v))));
  909.            canal[3].buffer[k]=(int)(fator*512.0*(sin(2.0*PI*fSinal.v.v*((float)k*dt.v.v))));
  910.            }
  911.            fase1+=2*PI/100;
  912.         canal[0].atualizou=true;
  913.         canal[1].atualizou=true;
  914.         canal[2].atualizou=true;
  915.         canal[3].atualizou=true;

  917.   }


  920. }


  923. void mouseClicked() {
  924.   //-- verificar se é para abrir Serial --
  925.   int r=com.mouseClicado();
  926.   if (r==1) { // retornou 1 então abrir serial
  927.     try {
  928.       //port=new Serial(this,com.ports[com.indPort],int(com.speeds[com.indSpeed]));
  929.       port=new Serial(this, com.ports[com.indPort], int(com.speeds[com.indSpeed]));
  930.       port.bufferUntil(10); //configurado para pegar linhas inteiras
  931.       com.conectado=true;
  932.       com.erro=false;


  935.     }
  936.     catch(Exception e) {
  937.       println("erro abrindo Serial:", e);
  938.       com.conectado=false;
  939.       com.erro=true;
  940.     }

  942.     if (com.conectado){      // start default was placed when eventSerial receives >init=v1.5
  943.       /*
  944.       //initProgram();
  945.       println("init delay 5000");
  946.       delay(5000);
  947.       println("end delay 5000");
  948.       for (int k=0;k<4;k++){
  949.         canal[k].chN.clicado=true;
  950.       }
  951.       // ligar uma amostra
  952.      variasAmostras.clicado=true;
  953.      if (variasAmostras.clicado) {
  954.         port.write("vo");
  955.       } else {
  956.         port.write("vx");
  957.       }
  958.       println("Abri Serial");
  959.       println("variasAmostra.clicado=",variasAmostras.clicado);
  960.       */
  961.     }

  963.   } else if (r==-1) { //retornou -1 então fechar serial
  964.     port.stop();
  965.     com.conectado=false;
  966.     com.versionArduino.tex="";
  967.     com.erro=false;
  968.   }

  970.   if (resetEixos.mouseClicado()){
  971.     for (int k=0; k<4;k++){
  972.      canal[k].p0=tela.y+3*Q*(k+1);//posição da tensão zero
  973.     }
  974.     resetEixos.clicado=false;
  975.   }

  977.   if (resetMedir.mouseClicado()){
  978.      for (int k=0; k<4;k++){
  979.         canal[k].telaClicou=false;
  980.      }
  981.      resetMedir.clicado=false;
  982.   }


  985.   /*
  986.   if (XYZ.mouseClicado()) {
  987.     if (XYZ.clicado) {
  988.       canal[0].chN.clicado=true;
  989.       canal[1].chN.clicado=false;
  990.       canal[2].chN.clicado=false;
  991.       canal[3].chN.clicado=false;
  992.     } else {
  993.       canal[1].chN.clicado=true;
  994.       canal[2].chN.clicado=true;
  995.       canal[3].chN.clicado=true;
  996.     }
  997.   }
  998.   */
  999.   chXYZ.mouseClicado();
  1000.   //XYZ.mouseClicado();
  1001.   // canais selecionados do XYZ
  1002.   /*
  1003.   for (int k=0;k<3;k++){
  1004.      if(selXYZ[k].mouseClicado()){
  1005.         int j=10-4-(parseInt(selXYZ[0].tex)+parseInt(selXYZ[1].tex)+parseInt(selXYZ[2].tex));
  1006.         selXYZ[k].tex=str(j);
  1007.         selXYZ[k].cor_ativo=cor[j];
  1008.         selXYZ[k].clicado=true;
  1009.      }
  1010.    }
  1011.    */
  1012.   // habilitar XYZ
  1013.   //XYZ.mouseClicado();  

  1015.   for (int k=0; k<4; k++) {
  1016.     if (canal[k].mouseClicado()){ // se alterou o Chn para visível ou não visível
  1017.        if (com.conectado){                           // enviar comando para o Arduino não ler esse canal
  1018.          if (canal[k].chN.clicado){
  1019.             port.write("c"+str(k)+"o");
  1020.          } else {
  1021.             port.write("c"+str(k)+"x");
  1022.          }
  1023.        }
  1024.        verificarQ();
  1025.     }
  1026.   }

  1028.   for (int k=0; k<3;k++){
  1029.     if (demo[k].mouseClicado()) { // Acionar o DEMO e desmarcas os outros 2
  1030.       if (demo[k].clicado) {
  1031.         int total=0;
  1032.         for (int k2=0; k2<3;k2++){
  1033.           if (demo[k2].clicado) total++;         
  1034.         }
  1035.         if (total<=1) {
  1036.           tonSinal.salvar();
  1037.           fSinal.salvar();
  1038.           tSinal.salvar();
  1039.         }
  1040.         for (int j=0; j<k; j++) {
  1041.           demo[j].clicado=false;
  1042.         }
  1043.         for (int j=2; j>k; j--) {
  1044.           demo[j].clicado=false;
  1045.         }
  1046.         tonSinal.alterar=altMove;
  1047.         fSinal.alterar=altMove;
  1048.         tSinal.alterar=altMove;
  1049.       } else {
  1050.         tonSinal.restaurar();
  1051.         tonSinal.alterar=altSolta;
  1052.         fSinal.restaurar();
  1053.         fSinal.alterar=altSolta;
  1054.         tSinal.restaurar();
  1055.         tSinal.alterar=altSolta;
  1056.       }
  1057.     }
  1058.   }



  1062.   // botões para medir tempo x tensão nos 4 canais (e botão de limpar x)
  1063.   /*
  1064.   for (int k=0;k<5;k++){
  1065.     if (medir[k].mouseClicado()){
  1066.        if (medir[k].clicado){
  1067.           for (int j=0; j<k;j++){
  1068.              medir[j].clicado=false;
  1069.           }
  1070.           for (int j=3;j>k;j--){
  1071.             medir[j].clicado=false;
  1072.           }
  1073.        }
  1074.        if (k==4){ // limpar os retangulos
  1075.          for (int i=0; i<4; i++){
  1076.             canal[i].telaClicou=false;
  1077.          }
  1078.        }
  1079.     }
  1080.   }
  1081.   */

  1083.   // botões para acionar o trigger nos canais
  1084.   /*
  1085.   for (int k=0;k<5;k++){
  1086.     if (trigger[k].mouseClicado()){
  1087.        if (trigger[k].clicado){
  1088.           for (int j=0; j<k;j++){
  1089.              trigger[j].clicado=false;
  1090.           }
  1091.           for (int j=4;j>k;j--){
  1092.             trigger[j].clicado=false;
  1093.           }
  1094.           //enviar comando para o Arduino
  1095.           if (com.conectado) {
  1096.             port.write("t"+trigger[k].tex);
  1097.           }      
  1098.        } else{
  1099.          if (com.conectado){
  1100.             port.write("tx");
  1101.          }
  1102.        }
  1103.     }
  1104.   }
  1105.   */

  1107.   verPontos.mouseClicado();
  1108.   calcFreq.mouseClicado();
  1109.   grafDif.mouseClicado();

  1111.   //08-Jun-2017 write data to file
  1112.   if (save.mouseClicado()){
  1113.         // 14-Jun-2017 save fluxo or save memory
  1114.         //println("fluxoContinuo.clicado=",fluxoContinuo.clicado);
  1115.         if (fluxoContinuo.clicado){
  1116.           if (outputOpen==false){ // não está gravando, então iniciar a gravação
  1117.             //println("outputOpen==false => ",outputOpen);
  1118.             String fileName ="dataf"+nf(year(),4)+nf(month(),2)+nf(day(),2)+nf(hour(),2)+nf(minute(),2)+nf(second(),2)+".txt";
  1119.             output=createWriter(fileName);
  1120.             outputOpen=true;
  1121.             save.tex="salvando";
  1122.             // cabeçalho
  1123.             //output.println("BegOscopio v"+versao+" "+nf(year())+"-"+nf(month())+"-"+nf(day())+" "+nf(hour())+":"+nf(minute())+":"+nf(second()));
  1124.             output.print("dt(");output.print(dt.v.printV());output.print(dt.unidade);output.print(")");
  1125.             for (int k=0; k<4; k++){
  1126.                if (canal[k].chN.clicado){
  1127.                  output.print('\t');output.print("ch");output.print(k);output.print("(mV)");
  1128.                }
  1129.             }
  1130.             output.println();
  1131.             qSave=0;
  1132.             // ao entrar cada dado no fluxo gravar em output.print()
  1133.             // gravar na rotina de entrada
  1134.           } else { // save já está gravando, então parar a gravação
  1135.             //println("outputOpen==true => ",outputOpen);
  1136.             output.close();
  1137.             outputOpen=false;
  1138.             qSave=1;
  1139.             if (qSave>10) {qSave=1;}
  1140.             save.tex="salvar datax.txt" + "-"+qSave;
  1141.             save.clicado=false;
  1142.           }
  1143.         } else {
  1144.           String fileName ="data"+nf(year(),4)+nf(month(),2)+nf(day(),2)+nf(hour(),2)+nf(minute(),2)+nf(second(),2)+".txt";
  1145.           output=createWriter(fileName);
  1146.           // cabeçalho
  1147.           //output.println("BegOscopio v"+versao+" "+nf(year())+"-"+nf(month())+"-"+nf(day())+" "+nf(hour())+":"+nf(minute())+":"+nf(second()));
  1148.           output.print("dt(");output.print(dt.v.printV());output.print(dt.unidade);output.print(")");
  1149.           for (int k=0; k<4; k++){
  1150.              if (canal[k].chN.clicado){
  1151.                output.print('\t');output.print("ch");output.print(k);output.print("(mV)");
  1152.              }
  1153.           }
  1154.           output.println();
  1155.           // dados
  1156.           float f=5000.0/1023.0;
  1157.           for (int k2=0; k2<q.v.v;k2++){
  1158.             output.print(k2);
  1159.             for (int k=0; k<4; k++) {
  1160.               if (canal[k].chN.clicado){
  1161.                 output.print('\t');output.print(int(canal[k].v[k2]*f));
  1162.               }
  1163.             }
  1164.             output.println();
  1165.           }

  1167.           output.close();
  1168.           qSave+=1;
  1169.           if (qSave>10) {qSave=1;}
  1170.           save.tex="salvar datax.txt" + "-"+qSave;
  1171.           save.clicado=false;
  1172.         }
  1173.   }
  1174.   //ruido.mouseClicado();

  1176.   //se clicou em dt ou q então enviar comando para Arduino e ajustar tela
  1177.   if (dt.mouseClicado()) { // se true alterou dt, então ajustarFt() (escala de t na tela)
  1178.     enviarDt();
  1179.     ajustarFt();
  1180.   }
  1181.   if (q.mouseClicado()) { // se true alterou q, então ajustarFt()
  1182.     enviarQ();
  1183.     ajustarFt();
  1184.   }

  1186.   if (RC.mouseClicado()) {
  1187.     if (com.conectado) {
  1188.       if (RC.clicado) {
  1189.         port.write("ro");
  1190.       } else {
  1191.         port.write("rx");
  1192.         RC.tex2="";
  1193.       }
  1194.     } else {
  1195.       RC.clicado=false;
  1196.     }
  1197.   }

  1199.   if (umaAmostra.mouseClicado()) { // receber apenas Uma Amostra
  1200.     variasAmostras.clicado=false;
  1201.     fluxoContinuo.clicado=false;
  1202.     if (outputOpen) {
  1203.       fecharDados();
  1204.     }
  1205.     if (com.conectado) {
  1206.       port.write("1");
  1207.     }
  1208.     umaAmostra.clicado=false;
  1209.     // verificar se tem algum trigger acionado para que ele fique esperando o disparo
  1210.     // vai ficar piscando para indicar que está aguardando o disparo.
  1211.     int k2=-1;
  1212.     for (int k=0; k<4;k++){
  1213.       if (canal[k].trigger.clicado) {
  1214.          k2=k;
  1215.          break;
  1216.       }
  1217.     }
  1218.     //println("k2=",k2);

  1220.     if (k2>=0 && k2<=3){
  1221.        pnlAmostra.piscar=true;
  1222.        canal[k2].trigger.piscar=true;
  1223.        esperandoTrigger=true;
  1224.     } else {
  1225.        pnlAmostra.piscar=false;
  1226.        esperandoTrigger=false;
  1227.      }
  1228.   }
  1229.   if (variasAmostras.mouseClicado()) {
  1230.     umaAmostra.clicado=false;
  1231.     fluxoContinuo.clicado=false;
  1232.     if (outputOpen) {
  1233.       fecharDados();
  1234.     }
  1235.     if (com.conectado) {
  1236.       if (variasAmostras.clicado) {
  1237.         port.write("vo");
  1238.       } else {
  1239.         port.write("vx");
  1240.       }
  1241.     } else {
  1242.       variasAmostras.clicado=false;
  1243.     }
  1244.   }
  1245.   if (fluxoContinuo.mouseClicado()) {
  1246.     umaAmostra.clicado=false;
  1247.     variasAmostras.clicado=false;
  1248.     if (com.conectado) {
  1249.       if (fluxoContinuo.clicado) {
  1250.         port.write("fo");

  1252.       } else {
  1253.         port.write("fx");
  1254.         if (outputOpen){
  1255.           fecharDados();
  1256.         }
  1257.       }
  1258.     } else {
  1259.       fluxoContinuo.clicado=false;
  1260.     }
  1261.   }

  1263.   if (sinal.mouseClicado()){
  1264.      if (com.conectado){
  1265.         if (sinal.clicado){
  1266.            port.write("so");
  1267.         } else {
  1268.            port.write("sx");
  1269.         }
  1270.      }
  1271.   }

  1273.   if (fSinal.mouseClicado()){
  1274.     tSinal.setV(1/fSinal.v.v);
  1275.     enviarCmd("tSinal");
  1276.   }
  1277.   if (tSinal.mouseClicado()){
  1278.      fSinal.setV(1/tSinal.v.v);
  1279.      enviarCmd("tSinal");
  1280.   }
  1281.   if (tonSinal.mouseClicado()){
  1282.     enviarCmd("tonSinal");
  1283.   }
  1284. }

  1286. void verificarQ(){
  1287.   chq=0; // contar qtd de canais ativos
  1288.   for (int k=0; k<4; k++){
  1289.      if (canal[k].chN.clicado){
  1290.        chq+=1;
  1291.      }
  1292.   }
  1293.   //q.vMax=408.0/chq;
  1294.   switch (chq){
  1295.      case 0:
  1296.        q.vMax=0;
  1297.        break;
  1298.      case 1:
  1299.        q.vMax=400;
  1300.        break;
  1301.      case 2:
  1302.        q.vMax=200;
  1303.        break;
  1304.      case 3:
  1305.        q.vMax=130;
  1306.        break;
  1307.      case 4:
  1308.        q.vMax=100;
  1309.        break;
  1310.   }
  1311.   if (q.v.v>q.vMax) {
  1312.     q.setV(q.vMax);
  1313.     ajustarFt();
  1314.   } else {
  1315.     q.setV(q.v.v);
  1316.   }
  1317. }

  1319. void mousePressed() {
  1320.   //d.mousePressionou();
  1321.   for (int k=0; k<4; k++) {
  1322.     canal[k].mousePressionou();
  1323.   }
  1324.   chXYZ.mousePressionou();
  1325.   dt.mousePressionou();
  1326.   q.mousePressionou();
  1327.   //ruido.mousePressionou();

  1329.   // só para aparecer o verde do pressionado
  1330.   umaAmostra.mousePressionou();
  1331.   variasAmostras.mousePressionou();
  1332.   fluxoContinuo.mousePressionou();

  1334.   fSinal.mousePressionou();
  1335.   tSinal.mousePressionou();
  1336.   tonSinal.mousePressionou();

  1338.   for (int k=0; k<3;k++){
  1339.      demo[k].mousePressionou();
  1340.   }
  1341.   resetEixos.mousePressionou();
  1342.   resetMedir.mousePressionou();

  1344. }

  1346. void mouseReleased() {
  1347.   // d.mouseSoltou();
  1348.   for (int k=0; k<4; k++) {
  1349.     canal[k].mouseSoltou();
  1350.   }
  1351.   chXYZ.mouseSoltou();

  1353.   for (int k=0; k<3;k++){
  1354.      demo[k].mouseSoltou();
  1355.   }
  1356.   resetEixos.mouseSoltou();
  1357.   resetMedir.mouseSoltou();
  1358.   // só para aparecer o verde do pressionado
  1359.   umaAmostra.mouseSoltou();
  1360.   variasAmostras.mouseSoltou();
  1361.   fluxoContinuo.mouseSoltou();


  1364.   //se soltar o mouse no dt ou q, então enviar os dados para o Arduino
  1365.   if (dt.mouseSoltou()) {
  1366.     enviarDt();
  1367.     ajustarFt();
  1368.   }
  1369.   if (q.mouseSoltou()) {
  1370.     enviarQ();
  1371.     // acertar as escalas ft de cada canal
  1372.     ajustarFt();
  1373.   }


  1376.   //ruido.mouseSoltou();

  1378.   if (fSinal.mouseSoltou()) {
  1379.     tSinal.setV(1/fSinal.v.v);
  1380.     enviarCmd("tSinal");
  1381.   }
  1382.   if (tSinal.mouseSoltou()) {
  1383.     fSinal.setV(1/tSinal.v.v);
  1384.     enviarCmd("tSinal");
  1385.   }
  1386.   if (tonSinal.mouseSoltou()){
  1387.     enviarCmd("tonSinal");
  1388.   }


  1391.   // controle do y do XYZ
  1392.   //if (XYZ.clicado){
  1393.   //    XYZyPegou=false;
  1394.   //}


  1397. }

  1399. void mouseMoved() {
  1400.   //teste
  1401.   //  canal[0].cor=get(mouseX,mouseY);
  1402.   //    println("cor=",canal[0].cor);
  1403.   com.mouseMoveu();

  1405.   for (int k=0; k<4; k++) {
  1406.     canal[k].mouseMoveu();
  1407.   }
  1408.   chXYZ.mouseMoveu();
  1409.   dt.mouseMoveu();
  1410.   q.mouseMoveu();
  1411.   //ruido.mouseMoveu();

  1413.   fSinal.mouseMoveu();
  1414.   tSinal.mouseMoveu();

  1416.   tonSinal.mouseMoveu();
  1417. }

  1419. void mouseDragged() {
  1420.   //d.mouseArrastou();
  1421.   for (int k=0; k<4; k++) {
  1422.     canal[k].mouseArrastou();
  1423.   }
  1424.   chXYZ.mouseArrastou();
  1425.   dt.mouseArrastou();
  1426.   q.mouseArrastou();
  1427.   //ruido.mouseArrastou();

  1429.   if (fSinal.alterar==altSolta){
  1430.     fSinal.mouseArrastou();
  1431.     tSinal.mouseArrastou();
  1432.   } else {
  1433.     if (fSinal.mouseArrastou()){
  1434.        tSinal.setV(1/fSinal.v.v);
  1435.     }
  1436.     if (tSinal.mouseArrastou()){
  1437.       fSinal.setV(1/tSinal.v.v);
  1438.     }
  1439.   }


  1442.   tonSinal.mouseArrastou();

  1444.   // controle do y do XYZ
  1445.   //if (XYZ.clicado){
  1446.   //   if (XYZyPegou){
  1447.   //    XYZy=constrain(mouseY,tela.y,tela.y+10*Q)-mouseOffSet;
  1448.   //   }
  1449.   //}
  1450. }


  1453. void keyReleased(){
  1454.   keyPressed=false;
  1455. }


  1458. void fecharDados(){
  1459.       output.close();  
  1460.       outputOpen=false;
  1461.       if (qSave>10) {qSave=1;}
  1462.       save.tex="salvar datax.txt" + "-"+qSave;
  1463.       save.clicado=false;
  1464. }


  1467. /* ==========================================
  1468.      Comando enviados para o Arduino
  1469.    ========================================== */

  1471. //=== Ger.Sinal - Se alterou f/T/Ton - enviar comando para Arduino ==
  1472. void enviarCmd(String cmd){
  1473.   if (cmd.equals("tSinal")){
  1474.     if (com.conectado){
  1475.          port.write("p"+tSinal.v.printV());
  1476.          println("p"+tSinal.v.printV());
  1477.      }
  1478.   } else if (cmd.equals("tonSinal")){
  1479.     if (com.conectado){
  1480.          port.write("o"+tonSinal.v.printV()+"%");
  1481.          println("o"+tonSinal.v.printV()+"%");
  1482.       }
  1483.   }
  1484. }

  1486. //==Se alterou dt ou q enviar comando para Arduino e ajustar a escala da tela ==
  1487. void enviarDt() {
  1488.   if (com.conectado) {
  1489.     port.write("d"+dt.v.printV());
  1490.   }
  1491.   // acertar as escalas ft de cada canal
  1492.   ajustarFt();
  1493. }
  1494. void enviarQ() {
  1495.   if (com.conectado) {
  1496.     port.write("q"+q.v.printV()+".");
  1497.   }
  1498. }

  1500. void ajustarFt() {
  1501.   float ftNew=dt.v.getV()*q.v.getV()/10.0;
  1502.   println("ftNew=",ftNew," dt=",dt.v.getV()," q=",q.v.getV());
  1503.   for (int k=0; k<4; k++) {
  1504.     canal[k].ft.setV(ftNew);
  1505.   }
  1506. }

  1508. /*=====================================
  1509.       Entrada do Evento Porta Serial
  1510.   =====================================*/
  1511. void serialEvent(Serial p) {
  1512.   //if (p.available()>0) {}
  1513. try {
  1514.   String cmd="", val="";
  1515.   String tex=p.readStringUntil(10);
  1516.   //print(">>>> ",tex); //eliminar
  1517.   if (tex.charAt(0)=='>') { //comando: >cmd=v1(tab)v2(tab)v3(tab)
  1518.     int i=tex.indexOf("=");
  1519.     if (i>=0) { // encontrou sinal "=" (igual)  obs: i=-1 => não encontrou o sinal '='
  1520.       cmd=tex.substring(1, i); // pegar o comando obs: substring(inclusive,exclusive)
  1521.       val=tex.substring(i+1); // pegar o valor
  1522.       //println("cmd=",cmd," val=",val);
  1523.       if (cmd.equals("init")) { // init
  1524.         println("versionArduino=<",val,">");
  1525.         com.versionArduino.tex=".ino "+val.substring(0,val.length()-1);
  1526.         //start all channels
  1527.         for (int k=0;k<4;k++){
  1528.           canal[k].chN.clicado=true;
  1529.         }
  1530.        // enviar dt
  1531.         enviarDt();
  1532.        // verificar e enviar q
  1533.        verificarQ();
  1534.         enviarQ();

  1536.         // send command to Arduino -> start Signal Gennerator 60Hz tOn25%
  1537.         enviarCmd("tSinal");
  1538.         enviarCmd("tonSinal");
  1539.         sinal.clicado=true;
  1540.         port.write("so");

  1542.         // ligar varias amostra
  1543.        variasAmostras.clicado=true;
  1544.        port.write("vo");

  1546.        //if (variasAmostras.clicado) {
  1547.        //   port.write("vo");
  1548.        // } else {
  1549.        //   port.write("vx");
  1550.        // }
  1551.         println("Abri Serial");
  1552.         println("variasAmostra.clicado=",variasAmostras.clicado);

  1554.       } else if (cmd.equals("f")) { // entra fluxo de dados - deslocar dados e armazenar no final
  1555.         String tex2[]=splitTokens(val); //val = "0(t)dtReal(t)ch0(t)ch1(t)ch2"
  1556.         //deslocar os dados para baixo, para incluir o novo dado no final
  1557.         for (int j=0; j<4; j++) {
  1558.           for (int k=1; k<q.v.v; k++) {
  1559.             canal[j].v[k-1]=canal[j].v[k];
  1560.           }
  1561.         }
  1562.         canal[0].v[int(q.v.v-1)]=int(tex2[2]);
  1563.         canal[1].v[int(q.v.v-1)]=int(tex2[3]);
  1564.         canal[2].v[int(q.v.v-1)]=int(tex2[4]);
  1565.         canal[3].v[int(q.v.v-1)]=int(tex2[5]);
  1566.         dtReal.setV(float(tex2[1]));
  1567.         if (dtReal.v-dt.v.v>1.1*dt.v.v){ dtErro=true;} else {dtErro=false;}

  1569.         // salvar em arquivo
  1570.         if (outputOpen) {
  1571.           float f=5000.0/1023.0;
  1572.           //for (int k2=0; k2<q.v.v;k2++){
  1573.             int k2=int(q.v.v-1);
  1574.             output.print(qSave);
  1575.             qSave+=1;
  1576.             for (int k=0; k<4; k++) {
  1577.               if (canal[k].chN.clicado){
  1578.                 output.print('\t');output.print(int(canal[k].v[k2]*f));
  1579.               }
  1580.             }
  1581.             output.println();
  1582.             if (qSave % 100==0) { // de 100 em 100
  1583.               save.tex="salvando "+nf(qSave);
  1584.               output.flush();
  1585.             }
  1586.           //}
  1587.         }

  1589.         //println("cmd=",cmd," val=",val," dtReal=",dtReal.printV());


  1592.       } else if (cmd.equals("chq")) {       // entra qtd e quais canais serão recebidos
  1593.         int v[]=int(splitTokens(val));
  1594. //voltar        //        println("========================");
  1595. //voltar        //        println("cmd=",cmd," val=",val);
  1596.         chq=v[0];
  1597.         for (int k=0;k<chq;k++){
  1598.           ch[k]=v[k+1];
  1599.         }
  1600. //voltar        //        println("chs=",chq);
  1601.         for (int k=0;k<chq;k++){
  1602. //voltar        //           println("ch[",k,"]=",ch[k]);
  1603.         }
  1604. //voltar        //        println("========================");
  1605.       } else if (cmd.equals("v")) { // entrada de Varias Amostra
  1606.         int v[]=int(splitTokens(val));
  1607. //voltar        //        println("tex=",tex);
  1608.         //println("cmd=",cmd," val=",val);
  1609.         //println("v.length=",v.length," chq=",chq);
  1610.         //for (int k=0; k<v.length; k++){
  1611.         //   print(" v[",k,"]=",v[k]);
  1612.         //}
  1613.         //println("");

  1615.         if (v.length==chq+1){ // >v=1 1024 100 300 300
  1616.           for (int k=0; k<chq; k++){
  1617.              canal[ch[k]].buffer[v[0]]=v[k+1];
  1618.           }
  1619.         }
  1620. /*   
  1621.         int kk=v[0]; // indice da matriz
  1622.         canal[0].buffer[v[0]]=v[1];
  1623.         canal[1].buffer[v[0]]=v[2];
  1624.         canal[2].buffer[v[0]]=v[3];
  1625.         canal[3].buffer[v[0]]=v[4];
  1626. */
  1627.     } else if (cmd.equals("q")) { // quantidade de variaveis
  1628.        // q.setV(float(val));
  1629.       } else if (cmd.equals("dt")) { // tamanho do dt (ms)
  1630.         //dt.val=float(val);
  1631.       } else if (cmd.equals("tTotalReal")) { // tempo total da amostra
  1632.         //println("atualizou");
  1633.         tTotalReal.setV(float(val));
  1634.         //text(tTotalReal,pnlAmostra.x+2,pnlAmostra.y+pnlAmostra.h);
  1635. //voltar        //        println("cmd=",cmd," val=",val," tTotalReal=",tTotalReal.printV());
  1636.         canal[0].atualizou=true;  // terminou de entrar os dados então
  1637.         canal[1].atualizou=true;  //  carregar do buffer
  1638.         canal[2].atualizou=true;
  1639.         canal[3].atualizou=true;
  1640.         if (esperandoTrigger){
  1641.            esperandoTrigger=false;
  1642.            pnlAmostra.piscar=false;
  1643.            for (int k=0; k<4;k++){
  1644.              canal[k].trigger.piscar=false;
  1645.            }

  1647.         }
  1648.       } else if (cmd.equals("dtReal")){
  1649.         dtReal.setV(float(val));
  1650.         if (dtReal.n>dt.v.n+10){ dtErro=true;} else {dtErro=false;}
  1651.         //text(dtReal,pnlAmostra.x+2,pnlAmostra.y+pnlAmostra.h-12);
  1652. //voltar        //        println("cmd=",cmd," val=",val," dtReal=",dtReal.printV());

  1654.       } else if (cmd.equals("r") || cmd.equals("c") || cmd.equals("rc")) { // valor do resistor
  1655.         String tex2[]=splitTokens(val, "\t\r");
  1656.         //i=val.indexOf("\t");
  1657.         //for (int k=0; k<tex2.length; k++){
  1658.         //   print("tex2[",k,"]=",tex2[k]);
  1659.         //}
  1660.         //println();
  1661.         if (cmd.equals("rc")) cmd="";
  1662.         RC.tex2=cmd.toUpperCase()+" "+tex2[1]+" ("+tex2[0]+")";

  1664.       } else if (cmd.charAt(0)=='?') {  // carregando as configurações do Arduino (ao conectar)
  1665.         cmd=cmd.substring(2); // eliminar 2 caracteres iniciais "? comando"
  1666.         val=val.substring(0,val.length()-2); // eliminar 2 caracteres finais:  \n\r(13,10)(^M^J) (retorno de linha)        
  1667. //voltar        //        println("cmd=",cmd," val=",val);
  1668.         if (cmd.equals("q")){ // val=100
  1669.           q.v.v=float(val);
  1670.         } else if (cmd.equals("dt")){
  1671.           char unid=val.charAt(val.length()-2);
  1672.           val=val.substring(0,val.length()-2);
  1673. //voltar        //          println("unid=",unid," val=",val);
  1674.           if (unid=='u'){
  1675.             val=val+"e-6";            
  1676.           }else{
  1677.             val=val+"e-3";
  1678.           }
  1679. //voltar        //          println("val=",val);
  1680.           dt.setV(float(val));
  1681.           ajustarFt();

  1683.         }else if (cmd.equals("canalTrigger")){ // val= 0,1,2,x
  1684.            for (int k=0;k<4;k++){canal[k].trigger.clicado=false;}
  1685.            if (!val.equals("x")){
  1686.               canal[int(val)].trigger.clicado=true;   
  1687.            }
  1688.         } else if (cmd.equals("uma")){ // val= 0 ou 1
  1689.           //umaAmostra.clicado=boolean(int(val));
  1690.         }else if (cmd.equals("varias")){ // val= 0 ou 1
  1691.           //variasAmostras.clicado=boolean(int(val));
  1692.         }else if (cmd.equals("fluxo")){ // val= 0 ou 1
  1693.           fluxoContinuo.clicado=boolean(int(val));
  1694.         }else if (cmd.equals("lerRC")){ // val= 0 ou 1
  1695.           RC.clicado=boolean(int(val));
  1696.         }else if (cmd.equals("pwmOn")){ // val=0 ou 1 (false/true)
  1697.           sinal.clicado=boolean(int(val));
  1698.           //println("sinal.clicado=",sinal.clicado," val=",val," boolean(val)=",boolean(val));
  1699.           //for (int k=0; k<val.length();k++){
  1700.           //   println(k," - ",val.charAt(k)," - ",byte(val.charAt(k)));
  1701.           //}
  1702.           //println("int(val)=",int(val)," int(''0'')",int("0")," int(''1'')",int(1));
  1703.           //println("b(''0'')=",boolean("0")," b(''1'')=",boolean("1")," b('0')=",boolean('0')," b('1')=",boolean('1'));
  1704.         }else if (cmd.equals("pwmP")){ // cmd="pwmP", val=" 100000us"
  1705.           val=val.substring(0,val.length()-2)+"e-6"; // remover "us" e colocar "e-6" (microsegundos)
  1706.           tSinal.setV(float(val));
  1707.           fSinal.setV(1/tSinal.v.v);
  1708.           //println("pwmP=",float(val));
  1709.         }else if (cmd.equals("pwmPon")){  // cmd="pwmPon", val="25%"
  1710.           val=val.substring(0,val.length()-1);
  1711.           tonSinal.setV(float(val));
  1712. //voltar        //          println("pwmPon=",float(val));
  1713.         }else {
  1714.            print("else >>>> ",tex);
  1715.          }
  1716.       }
  1717.     }
  1718.     //println("cmd=",cmd);
  1719.     //println("val=",val);
  1720.   }
  1721. }
  1722. catch(RuntimeException e){
  1723.     e.printStackTrace();

  1725. }
  1726. }
复制代码

* Processing 版本3.5.3

评分

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

查看全部评分

回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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