单片机教程网

电脑版
提示:原网页已由神马搜索转码, 内容由www.51hei.com提供.
查看:2246|回复: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

评分

黑币 +100
收起理由
+ 100
共享资料的黑币奖励！

查看全部评分

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

Powered by 单片机教程网