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

#define versao "v1.5"
#include <TimerOne.h>
const unsigned char PS_16 = (1 << ADPS2);
const unsigned char PS_32 = (1 << ADPS2) | (1 << ADPS0);
const unsigned char PS_64 = (1 << ADPS2) | (1 << ADPS1);
const unsigned char PS_128 = (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
boolean pwmOn=true;
unsigned long pwmP=20000; //Periodo 20000us=20ms=0.02s => 50Hz
byte pwmPon=25; // % do pwmP em HIGH
int vb[400]; // (100*4=400) buffer stores the measure values of all channels
int chi[]={0,100,200,300}; // channel init position on buffer vb[]
int chq=4; // how many channels are ON
int q=100; // quantidade de leituras
int qmax=100; // qtd maxima permitida para q
int vtrigger=0; // tensao de trigger
boolean Ch[]={true,true,true,true}; // ativa/desativa canais
unsigned int dt=4; // 100us a 1000us(1ms) a 3000ms(3s)
char unidade='m'; // unidade: m=milisegundo, u=microsegundo
boolean varias=false; // v = varias
boolean uma=false; // u = uma
boolean fluxo=false; // f = fluxo de dados (envia cada leitura sem guardar na memoria)
unsigned long dtReal, tIni, tFim; // contador de final de tempo para o fluxo
char canalTrigger='x'; // de '0','1','2','3' (canal do trigger), 'x'=não tem trigger
//--------------- Ler Resistor/Capacitor ---------
boolean lerRC=false;
#define pinV 5
#define pinA 10 // pino A 10 multiplex
#define pinB 9 // pino B 9 multiplex
byte entrada=0;
int vi, vf, v;
unsigned long dtRC=0;
char unidadeRC=' ';
boolean debug=true;
void setup() {
ADCSRA &= ~PS_128; //limpa configuração da biblioteca do arduino
ADCSRA |= PS_16; // 16 prescaler
pinMode(10,OUTPUT);
Timer1.initialize(pwmP); //100000us=100ms=>10Hz
Timer1.pwm(9,map(pwmPon,0,100,0,1023)); //pwm no pino9 com 25% duty cycle
Timer1.attachInterrupt(callback); //attaches callback() como timer overflow interrupt
Serial.begin(9600);
//Serial.begin(115200);
//Serial.begin(250000);
Serial.println();
Serial.print(">init="); Serial.println(versao);
pinMode(pinA,OUTPUT);
pinMode(pinB,OUTPUT);
selecionar(0);
}
void callback(){
digitalWrite(10,digitalRead(10)^1); // ^1 = xor (0->1, 1->0)
}
void loop() {
lerSerial();
if (varias) {
lerEnviar();
} else if (uma) {
if (canalTrigger=='x'){
lerEnviar();
uma=false;
} else {
if (trigger()){
lerEnviar();
uma=false;
}
}
} else if (fluxo) {
lerFluxo();
}
if (lerRC){
if (millis()>=dtRC){
lerResistorCapacitor();
dtRC=millis()+3000;
}
}
}
void lerSerial(){
int k;
float kf;
char c, c2;
if (Serial.available()>0){
c=Serial.read();
switch (c){
case 'h': // enviar help pela serial
printHelp();
break;
case 'd': //alterar o valor de dt (us/ms)
k=Serial.parseInt(); // como e inteiro então vai de 0 a 32767 (parseint limita 16bits)
if (k>=1 && k<=30000) {//28/08/15 deve ser dtmin=400us(3canais) dtmax=30000
dt=k;
}
c=Serial.read();
if (c=='u' || c=='m'){
unidade=c;
} else { // sem unidade é segundo, então converter para mili (x1000)m
unidade='m';
dt*=1000;
}
// Serial.print("=> dt="); Serial.print(dt); Serial.print(unidade); Serial.println("s");
break;
case 'q': // alterar valor do q.(ponto no final) (quantidade de leituras)
k=Serial.parseInt(); // inteiro de 0 a 32767
c=Serial.read(); // para ir mais rápido colocar um . no final ex: q150.
if (k>=1 && k<=qmax) {
q=k;
}
//calcBuffer(); //não precisa pois será usado o qmax
Serial.print("=> q="); Serial.println(q);
break;
case 'c': //cnm : n=0-3, m=(o)ativa/(x)desativa canal n exemplo: c0x, c2o
delay(100);
c=Serial.read();
delay(100);
c2=Serial.read();
if (c>='0' && c<='3'){
if (c2=='o'){
Ch[c-'0']=true;
}else if (c2=='x'){
Ch[c-'0']=false;
}
// recalcular o buffer para cada canal e colocar o indice
// inicial para cada canal
//Serial.println("entrar calcBuffer");
calcBuffer();
//Serial.println("saiu calcBuffer");
/* Serial.print("=> Canais: ");
for (k=0; k<3;k++){
Serial.print("Ch"); Serial.print(k); Serial.print("="); Serial.print(Ch[k]);
}
Serial.println();
*/
}
break;
case 't': // trigger: t(canal)
// trigger: t0, t1, t2, t3
// tx desligado
// tv512. valor da tensão 0-1024 (5v)
delay(100);
c=Serial.read();
if ((c>='0' && c<='3') || c=='x'){
canalTrigger=c;
} else if (c=='v'){
k=Serial.parseInt();
c=Serial.read();
if (k>=0 && k<=1024) {
vtrigger=k;
}
}
// Serial.print("=> canalTrigger="); Serial.println(canalTrigger);
break;
case '?':
printConfig();
break;
case '1': // enviar Uma Amostra (q leituras)
if (!uma) uma=true;
if (uma){
varias=false;
fluxo=false;
}
// Serial.print("=> uma="); Serial.println(uma);
break;
case 'v': // o(on)/x(off) - enviar Varias Amostras (q leituras cada)
delay(100);
c=Serial.read();
if (c=='o') {
varias=true;
} else {
varias=false;
}
if (varias){
uma=false;
fluxo=false;
}
// Serial.print("=> varias="); Serial.println(varias);
break;
case 'f': // o(on)/x(off) - enviar Fluxo (ler e enviar - nao armazenar)
delay(100);
c=Serial.read();
if (c=='o') {
fluxo=true;
} else {
fluxo=false;
}
if (fluxo){
varias=false;
uma=false;
if (unidade=='u'){ // microsegundo
tIni=micros(); tFim=tIni+dt;
} else{ // milisegundo
tIni=millis(); tFim=tIni+dt;
}
}
// Serial.print("=> fluxo="); Serial.println(fluxo);
break;
case 'r': // (on/off) - enviar valor lido do Resistor em A5
delay(100);
c=Serial.read();
if (c=='o') {
lerRC=true;
} else {
lerRC=false;
}
// Serial.print("=> lerRC="); Serial.println(lerRC);
dtRC=0;
break;
case 's': // Sinal: Ligar/desligar Gerador de Sinal
delay(100);
c=Serial.read();
if (c=='o'){
Timer1.restart(); // zera o contador
Timer1.start(); //inicio
// Serial.println("Timer1 restart/start");
}else{
Timer1.stop();
// Serial.println("Timer1.stop()");
}
break;
case 'p': // Sinal: alterar Período ex: p100m p343u
kf=Serial.parseFloat();
if (kf>0){
c=Serial.read(); // ler unidade e converter para micro
// Serial.print(">>kf="); Serial.print(kf); Serial.print(" c="); Serial.println(c);
switch (c){
case 'u': //já está em micro (u)
pwmP=long(kf);
break;
case 'm': // está em mili (m) então converter para micro (u)
pwmP=long(kf*1000.0);
// Serial.print("kf="); Serial.print(kf); Serial.print("m"); Serial.print(" pwmP=kf*1000="); Serial.println(pwmP);
break;
case ' ': // está em segundo ( ) então converter para micro (u)
pwmP=long(kf*1000000.0);
break;
default: // se veio caracter desconhecido faço o pwmP=1s
pwmP=1000000l; // coloquei L no final do 100000 para dizer que é long
// Serial.print("=> erro unidade pwmP, usando padrao(us)="); Serial.println(1000000);
break;
}
Timer1.setPeriod(pwmP);
Timer1.setPwmDuty(9,map(pwmPon,0,100,0,1023));
// Serial.print("=> setPeriod="); Serial.println(pwmP);
}
break;
case 'o': // Sinal: alterar tempo em ON ex: o25% o50%
k=int(Serial.parseFloat());
c=Serial.read(); // só ler a % e desprezar (faz o parseInt ficar mais rapido
if (k>=0 && k<=100){
pwmPon=k;
Timer1.setPwmDuty(9,map(pwmPon,0,100,0,1023));
// Serial.print("=> pwm on="); Serial.print(k); Serial.println("%");
}
break;
default:
Serial.print("erro c="); Serial.println(c,HEX);
}
}
}
void calcBuffer(){
//Serial.println("entrou calcBuffer");
chq=0;
// conta a quantidade de canais ativos
for (int k=0;k<4;k++){
if (Ch[k]) {chq+=1;}
}
// calc size of each channel
switch (chq){
case 0:
qmax=0;
break;
case 1:
qmax=400;
break;
case 2:
qmax=200;
break;
case 3:
qmax=130;
break;
case 4:
qmax=100;
break;
}
/*
if (chq<=0) {
qmax=0;
} else {
qmax=408/chq; // chq-qmax; 4-102; 3-136; 2-204; 1-408
}
*/
if (q>qmax) {
q=qmax;
}
//Serial.print("q=408/chq=");Serial.print("408/");Serial.print(chq);Serial.print("=");Serial.println(q);
// qtdCanais-qmax (chq-qmax) (4-100) (3-130) (2-200) (1-400)
int chInit=0;
for (int k=0; k<4; k++){
if (Ch[k]) {
chi[k]=chInit;
chInit+=qmax;
}
}
// Serial.print("chq="); Serial.print(chq); Serial.print(" q="); Serial.print(q); Serial.print(" qmax="); Serial.println(qmax);
// for (int k=0; k<4; k++){
// Serial.print("k=");Serial.print(k); Serial.print(" chi[k]="); Serial.println(chi[k]);
// }
}
void printHelp(){
Serial.println("-----------------------");
Serial.print("! BegOscopio "); Serial.print(versao); Serial.println(" - [email]rogerio.bego@hotmail.com[/email] !");
Serial.println("-----------------------");
/*
Serial.println("----------- help ---------------------");
Serial.println(" h : help");
Serial.println(" ? : exibir as configuracoes atuais");
Serial.println(" -------- controle da amostragem ------");
Serial.println(" d___ : d[1-3000][un] - ex: d100m, d200u - dt = intervalo de tempo (us/ms) entre as leituras");
Serial.println(" q___ : q[1-100]. - qtd de leituras");
Serial.println(" cn_ : (o)ativa,(x)desativa canal: ex: c2o (ativar Ch2), c0x (desativar Ch0)");
Serial.println(" t_ : 0,1,2,3(canal),x(off) ");
Serial.println(" tv__ : tv512. valor da tensao 0-1024 (0-5v)");
Serial.println(" -------- envio das amostras ---------");
Serial.println(" 1 : enviar uma amostra");
Serial.println(" v_ : o(on),x(off) enviar varias amostras");
Serial.println(" f_ : o(on),x(off) enviar fluxo de dados");
Serial.println(" obs: 1, v, f sao mutuamente excludentes");
Serial.println(" -------- leitura de Resistor ou Capacitor ----");
Serial.println(" r_ : o(on),x(off) ler Resistor ou Capacitor");
Serial.println(" -------- Gerador de Sinal pwm ---------");
Serial.println(" s_ : o(on),x(off) ativa Ger.Sinal (pwm na porta 9) (porta 10 indica 2*T)");
Serial.println(" p_ : p[valor][unidade] periodo do sinal de 100u a 8s");
Serial.println(" o_ : o[0-100][%] Ton em porcentagem");
Serial.println("----------------------------------------");
*/
}
void printConfig(){
Serial.println("------ configuracoes -------");
Serial.print(">? q="); Serial.println(q);
Serial.print(">? qmax="); Serial.println(qmax);
Serial.print(">? dt="); Serial.print(dt); Serial.print(unidade); Serial.println("s");
float t=(float)q * (float)dt;
Serial.print(" -> T=(q*dt)= "); Serial.print(t); Serial.print(unidade); Serial.println("s ");
Serial.print(">? Canais: ");
for (int k=0; k<4; k++){
Serial.print(" Ch"); Serial.print(k); Serial.print("=");
if (Ch[k]) {
Serial.print("o");
} else {
Serial.print("x");
}
}
Serial.println();
Serial.print(">? canalTrigger="); Serial.println(canalTrigger);
Serial.print(">? uma="); Serial.println(uma);
Serial.print(">? varias="); Serial.println(varias);
Serial.print(">? fluxo="); Serial.println(fluxo);
Serial.print(">? lerRC="); Serial.println(lerRC);
Serial.print(">? pwmOn="); Serial.println(pwmOn);
Serial.print(">? pwmP="); Serial.print(pwmP); Serial.println("us");
Serial.print(">? pwmPon="); Serial.print(pwmPon); Serial.println("%");
}
unsigned long microsOuMillis(){
if (unidade=='u'){
return micros();
} else {
return millis();
}
}
//-- procurar tensão maior que zero no canalTrigger ----
//-- se UMA=true então fica aguardando indefinitivamente
//-- se UMA=false então fica aguardando até o tempo tFIM (q*dt)
boolean trigger(){ // a variavel canalTrigger indica qual canal fará o trigger: 0,1,2 ou 3
unsigned long tFim; // contador do tempo Final
int v1=0,v2=0;
//int c1=0, c2=0;
boolean achou=false;
tFim=microsOuMillis()+q*dt;
// dispara na subida do valor vtrigger+10
//fica lendo a tensão enquanto for maior que vtrigger
// E tempo menor que tFim
do{
v1=analogRead(canalTrigger-'0');
//c1++;
}while (v1>vtrigger && microsOuMillis()<tFim);
// while (v1=analogRead(canalTrigger-'0')>0 && microsOuMillis()<tFim){c1++;}
if (v1<=vtrigger){
tFim=microsOuMillis()+q*dt;
//fica lendo a tensão enquanto for menor ou igual a 10+vtrigger
// E tempo menor que tFim
do{
v2=analogRead(canalTrigger-'0');
//c2++;
}while(v2<=10+vtrigger && microsOuMillis()<tFim);
//while (v2=analogRead(canalTrigger-'0')<=0 && microsOuMillis()<tFim){c2++;}
if (v2>10+vtrigger){
achou=true;
}
//Serial.print("v1="); Serial.print(v1); Serial.print(" v2=");Serial.println(v2);
//Serial.print("c1=");Serial.print(c1);Serial.print(" c2=");Serial.println(c2);
}
return achou;
}
void lerEnviar(){
/*
// enviar quais canais serao enviados. ex: >ch=1<\t>3<\t>
Serial.print(">chq="); Serial.print(chq); Serial.print("\t");
for (int k=0; k<4; k++){
if (Ch[k]){Serial.print(k); Serial.print("\t");}
}
Serial.println("");
//enviar os valores dos canais
for (int k=0; k<q; k++){
Serial.print(">v="); Serial.print(k); Serial.print("\t");
if (Ch[0]) {Serial.print(chi[0]+k); Serial.print("\t");}
if (Ch[1]) {Serial.print(chi[1]+k); Serial.print("\t");}
if (Ch[2]) {Serial.print(chi[2]+k); Serial.print("\t");}
if (Ch[3]) {Serial.print(chi[3]+k); Serial.print("\t");}
Serial.println("");
}
return;
*/
unsigned long tFim; // contador do tempo Final
unsigned long tTotalReal; // tempo Total da leitura dos valores.
if (canalTrigger>='0' && canalTrigger<='3'){
//Serial.print("canalTrigger=");Serial.println(canalTrigger);
Serial.print("trigger="); Serial.println(trigger());
}
tTotalReal=microsOuMillis();
for (int k=0; k<q; k++){
tFim=microsOuMillis()+dt;
/*
if (Ch[0]) {v0[k]=analogRead(A0);}
if (Ch[1]) {v1[k]=analogRead(A1);}
if (Ch[2]) {v2[k]=analogRead(A2);}
if (Ch[3]) {v3[k]=analogRead(A3);}
*/
if (Ch[0]) {vb[chi[0]+k]=analogRead(A0);}
if (Ch[1]) {vb[chi[1]+k]=analogRead(A1);}
if (Ch[2]) {vb[chi[2]+k]=analogRead(A2);}
if (Ch[3]) {vb[chi[3]+k]=analogRead(A3);}
while (microsOuMillis()<tFim){}
}
tTotalReal=microsOuMillis()-tTotalReal; // total de tempo para ler todas as amostras
dtReal=tTotalReal/q; // calcular o tempo médio de cada leitura
Serial.println();
Serial.print(">q="); Serial.println(q);
Serial.print(">dt="); Serial.print(dt); Serial.print(unidade); Serial.println("s");
Serial.print(">dtReal="); Serial.print(dtReal); // Serial.print(unidade); Serial.println("s");
if (unidade=='m'){
Serial.println("e-3");
}else if (unidade=='u'){
Serial.println("e-6");
}
// enviar quais canais serao enviados. ex: >ch=1<\t>3<\t>
Serial.print(">chq="); Serial.print(chq); Serial.print("\t");
for (int k=0; k<4; k++){
if (Ch[k]){Serial.print(k); Serial.print("\t");}
}
Serial.println("");
//enviar os valores dos canais
for (int k=0; k<q; k++){
Serial.print(">v="); Serial.print(k); Serial.print("\t");
if (Ch[0]) {Serial.print(vb[chi[0]+k]); Serial.print("\t");}
if (Ch[1]) {Serial.print(vb[chi[1]+k]); Serial.print("\t");}
if (Ch[2]) {Serial.print(vb[chi[2]+k]); Serial.print("\t");}
if (Ch[3]) {Serial.print(vb[chi[3]+k]); Serial.print("\t");}
Serial.println("");
/*
if (Ch[0]) {Serial.print(chi[0]+k); Serial.print("\t");}
if (Ch[1]) {Serial.print(chi[1]+k); Serial.print("\t");}
if (Ch[2]) {Serial.print(chi[2]+k); Serial.print("\t");}
if (Ch[3]) {Serial.print(chi[3]+k); Serial.print("\t");}
Serial.println("");
*/
}
/* -- eliminado em 07/May/2017 - criei buffer dinamico vb[408] --
for (int k=0; k<q; k++){
Serial.print(">v=");
Serial.print(k); Serial.print("\t");
Serial.print(v0[k]); Serial.print("\t");
Serial.print(v1[k]); Serial.print("\t");
Serial.print(v2[k]); Serial.print("\t");
Serial.println(v3[k]);
}
*/
Serial.print(">tTotalReal="); Serial.print(tTotalReal); //Serial.print(unidade); Serial.println("s");
if (unidade=='m'){
Serial.println("e-3");
}else if (unidade=='u'){
Serial.println("e-6");
}
}
void lerFluxo(){
int v0, v1, v2, v3; // guarda os valores das leituras
//byte v0, v1, v2, v3; // guarda os valores das leituras
boolean leu=false;
if (microsOuMillis()>=tFim){
dtReal=microsOuMillis()-tIni;
tIni=microsOuMillis(); tFim=tIni+dt;
if (Ch[0]) {v0=analogRead(A0);}
if (Ch[1]) {v1=analogRead(A1);}
if (Ch[2]) {v2=analogRead(A2);}
if (Ch[3]) {v3=analogRead(A3);}
//if (Ch[0]) {v0=analogRead(A0)/4;}
//if (Ch[1]) {v1=analogRead(A1)/4;}
//if (Ch[2]) {v2=analogRead(A2)/4;}
//if (Ch[3]) {v3=analogRead(A3)/4;}
leu=true;
}
if (leu){
Serial.print(">f=");
Serial.print("0"); Serial.print("\t");
Serial.print(dtReal);
if (unidade=='m'){
Serial.print("e-3");
}else if (unidade=='u'){
Serial.print("e-6");
}
Serial.print("\t");
if (Ch[0]) {Serial.print(v0);} else {Serial.print("0");} Serial.print("\t");
if (Ch[1]) {Serial.print(v1);} else {Serial.print("0");} Serial.print("\t");
if (Ch[2]) {Serial.print(v2);} else {Serial.print("0");} Serial.print("\t");
if (Ch[3]) {Serial.println(v3);} else {Serial.println("0");}
}
}
//=========== Rotinas para leitura de Resistor e Capacitor ===========
void lerResistorCapacitor(){
descarregar();
lerEntrada(1);
if (vf-vi>=100) {// e' capacitor
calcCapacitor();
} else {
if (v<900) { // calcular valor do resistor
calcRx();
} else { // subir selecionar 2
// descarregar se for capacitor
descarregar();
lerEntrada(2);
if (vf-vi>=100) { // capacitor - escala 2
calcCapacitor();
} else { // resistor
if (v<900){ // calcular valor do resistor
calcRx();
} else { // subir selecionar 3 (nao consegue detectar capacitor corretamente)
lerEntrada(3);
if (v<900){
calcRx();
} else {
Serial.println(">rc=3\tColoque RC");
}
}
}
}
}
}
void calcCapacitor(){
float re[]={0.0,145.2,20692.9,1017847.5};
float cx=0;
descarregar();
selecionar(1);
dtRC=millis();
while (analogRead(pinV)<647){} // 647 = 63.2% Vcc => (nessa voltagem t=rc)
dtRC=millis()-dtRC;
if (dtRC>=100) { // dentro da faixa Cx>1mF
cx=(float)dtRC/re[entrada];
unidadeRC='m'; //resultado em mF
} else { // fora da faixa, subir para escala 2
descarregar();
selecionar(2);
dtRC=millis();
while (analogRead(pinV)<647){}
dtRC=millis()-dtRC;
if (dtRC>=10) { // dentro da faixa
cx=(float)dtRC*1000.0/re[entrada];
unidadeRC='u'; // resultado em uF
} else { // fora da faixa, então subir escala
descarregar();
selecionar(3);
dtRC=millis();
while (analogRead(pinV)<647){}
dtRC=millis()-dtRC;
cx=(float)dtRC*1000000.0/re[entrada];
unidadeRC='n'; // resultado em nF
}
}
Serial.print(">c="); Serial.print(entrada); Serial.print("\t"); Serial.print(cx); Serial.print(" "); Serial.print(unidadeRC); Serial.println("F");
}
void lerEntrada(byte e){
selecionar(e);
dtRC=micros();
vi=analogRead(pinV);
v=0;
for (int k=0; k<10; k++){
v+=analogRead(pinV);
}
v/=10;
vf=analogRead(pinV);
dtRC=micros()-dtRC;
}
void descarregar(){
selecionar(0);
while (analogRead(pinV)>0){}
}
void calcRx(){
float re[]={0.0,145.2,20692.9,1017847.5};
float vcc[]={0,871.5,1026.3,1027.1};
float rx=0;
rx=re[entrada]*(float)v/(vcc[entrada]-(float)v);
Serial.print(">r="); Serial.print(entrada); Serial.print("\t");
switch (entrada) {
case 1:
if (rx>=1000){
rx/=1000;
Serial.print(rx); Serial.println(" Kohm");
} else {
Serial.print(rx); Serial.println(" ohm");
}
break;
case 2:
Serial.print(rx/1000); Serial.println(" Kohm");
break;
case 3:
Serial.print(rx/1000000); Serial.println(" Mohm");
break;
}
}
void selecionar(byte e){
entrada=e;
digitalWrite(pinA,bitRead(entrada,0));
digitalWrite(pinB,bitRead(entrada,1));
}
Processing示波器代码(部分修改):
String versao="v1.0";
PFont font;
byte escLinear=0; // Dial com escala linear
byte escLog=1; // Dial com escala logarítimica (base 10)
byte altMove=2; // mudar o valor ao arrastar o mouse "MouseDragged"
byte altSolta=3; // mudar o valor ao soltar o botão do mouse "MouseReleased"
boolean nInt=true; // n é inteiro (arredondar), ou decimal !nInt
boolean fmt=true; // fmt=true="formatar", !fmt=false="não formatar"
boolean esperandoTrigger=false;
int vTrigger=0; // valor do trigger (subindo) 0-1024 (0-5v)
color cor[]={color(255, 0, 0), color(0, 255, 0), color(0, 0, 255), color(255,255,0)}; // canais: red,green,blue,yellow
import processing.serial.*;
PrintWriter output;
boolean outputOpen=false;
Botao save;
int qSave=0;
Serial port;
Com com;
Tela tela;
CanalXYZ chXYZ;
Botao resetEixos;
Botao resetMedir;
Canal canal[]=new Canal[4];
//byte chq=4; // qtd de canais ativos
Grupo grupo[]=new Grupo[3]; // usado para alterar v/div e ms/div simultaneamente em todos os canais usando SHIFT
// painel para os controles de Amostragem
Painel pnlAmostra; // painel
Dial dt; // delta t (tempo de cada leitura)
Dial q; // quantidade de leituras
Botao umaAmostra; // solicita uma Amostra
Botao variasAmostras; // solicita várias Amostras
Botao fluxoContinuo; // entra com leitura a cada dt
FmtNum tTotal; // tempo total da amostragem dt*q
Botao demo[]=new Botao[3]; // botões para gerar sinais de demonstração
float fase1, fase2, t1, t2; // fase dos DEMO //para noise(t) do demo
CheckBox verPontos; // ver os pontos da amostragem
CheckBox calcFreq; // detectar frequencia
CheckBox grafDif; // (ver) mostrar gráfico Diferença (parecido com a derivada)
//Dial ruido; // usado para melhorar a detecção da frequencia
// painel para medir resistor/capacitor
Painel pnlRC; // o valor é colocado em tex2 do CheckBox RC
CheckBox RC; // ativa/desativa medidor de resistor/capacitor
// painel para o Gerador de Sinal
Painel pnlSinal;
CheckBox sinal; // f e t são dependentes f=1/t, t=1/f
Dial fSinal; // f (frequencia) do Sinal (10kHz-0.125Hz)
Dial tSinal; // T (período) do Sinal (100us-8s)
Dial tonSinal; // tempo em ON (0-100%)
// verificar se o tempo de leitura Real é igual ao desejado
FmtNum tTotalReal, dtReal; // tempos reais de leitura enviados pelo Arduino
boolean dtErro=false;
float Q=45.0; //tamanho do quadrado na tela
int chq=4; // qtd de canais selecionados (visiveis)
//int qMax=102; // chq-qMax: 4-102, 3-136, 2-204, 1-408
int ch[]={0,1,2,3}; // quais canais estão visiveis (ON)
//temporarios
int marg1, marg2; //margem temporaria para ajustar a posição dos objetos
void setup() {
size(680, 700);
font = createFont("宋体.vlw",48);
textFont(font);
//size(800,700);
frameRate(10);
tela=new Tela(30+10, 60, 10*Q, 12*Q); //horizontal 10divisoes , vertical 12divisoes
marg1=tela.x+tela.w+10;
marg2=marg1+200;
com=new Com(port, tela.x+tela.w-250, 5, 250, 55);
for (byte k=0; k<3; k++){ // deve estar antes do canal
grupo[k]=new Grupo();
}
resetEixos=new Botao("eixos",marg1+50,tela.y,45,20);
resetMedir=new Botao("medir",resetEixos.x+resetEixos.w+2,tela.y,45,20);
//demo & canais
for (byte k=0; k<4; k++) {
if (k<3) {demo[k]=new Botao(str(k+1), marg1+50+k*30, tela.y/2-10, 30, 20);}
canal[k]=new Canal(k, cor[k], marg1, tela.y+27+k*110, 143, 100); //h115
}
chXYZ=new CanalXYZ(color(255,0,255),marg1,canal[3].y+canal[3].h+10,143,80);
chXYZ.verCanais.clicado=true;
verPontos=new CheckBox("ver pontos", chXYZ.x, chXYZ.y+chXYZ.h+5, 15);
calcFreq=new CheckBox("detectar freq.", verPontos.x, verPontos.y+verPontos.h+5, 15);
grafDif=new CheckBox("ver",calcFreq.x+calcFreq.w,calcFreq.y,15);
save=new Botao("salvar datax.txt",calcFreq.x,calcFreq.y+calcFreq.h+5,150,20);
//medidor de resistor/capacitor
pnlRC=new Painel("", tela.x, tela.y+tela.h+10, 125, 40);
RC=new CheckBox("medir res./cap.", pnlRC.x, pnlRC.y, 15);
//Gerador de Sinais - agora só gera onda quadrada, depois vai gerar triangulo, denteDeSerra, e senidal
pnlSinal=new Painel("", pnlRC.x+pnlRC.w+10, pnlRC.y, 100, 85);
sinal=new CheckBox("Ger.Sinal", pnlSinal.x, pnlSinal.y, 15);
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);
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);
tonSinal=new Dial(escLinear, altSolta, nInt, !fmt, "Ton", "%", 25f, 0f, 100f, tSinal.x, tSinal.y+tSinal.h+2, tSinal.w, tSinal.h);
// posicionamento da Amostragem
pnlAmostra=new Painel("Amostragem", pnlSinal.x+pnlSinal.w+10, pnlSinal.y, 200, 85);
dt=new Dial(escLog, altSolta, nInt, fmt, "dt", "s", 1e-3f, 10e-6f, 2f, pnlAmostra.x+5, pnlAmostra.y+20, 100, 20);
dtReal=new FmtNum(0,nInt,fmt);
q=new Dial(escLinear, altSolta, nInt, !fmt, "q", "", 100, 1, 100, dt.x+dt.w+5, dt.y, 60, 20);
tTotal=new FmtNum(dt.v.getV()*q.v.getV(), !nInt);
tTotalReal=new FmtNum(0,!nInt);
umaAmostra=new Botao("uma", dt.x, dt.y+dt.h+5, 50, 20);
variasAmostras=new Botao("varias", umaAmostra.x+umaAmostra.w+5, umaAmostra.y, umaAmostra.w, umaAmostra.h);
fluxoContinuo=new Botao("fluxo", variasAmostras.x+variasAmostras.w+5, variasAmostras.y, variasAmostras.w, variasAmostras.h);
}
void draw() {
//==== Construir a tela e mostrar os controles =========
background(100);
fill(0, 255, 255);
textAlign(LEFT, TOP);
textSize(18);
text("四通道示波器 "+versao, tela.x, 12);
fill(0);
textSize(12);
text(" DiscoverySoft.com", tela.x, tela.y-15);
tela.display();
textSize(15);
fill(0);
textAlign(RIGHT, CENTER);
text("演示", demo[0].x-5, demo[0].y+demo[0].h/2); //tela.x+tela.w+10,tela.y);
text("重置",resetEixos.x-5,resetEixos.y+resetEixos.h/2);
chXYZ.display();
for (byte k=0; k<4; k++) {
if (k<3){demo[k].display();}
canal[k].display();
}
verPontos.display();
calcFreq.display();
grafDif.display();
//ruido.display();
save.display();
com.display();
resetEixos.display();
resetMedir.display();
tTotal.setV(dt.v.getV()*q.v.getV());
pnlAmostra.tex2="("+tTotal.printV()+"s)";
pnlAmostra.display();
dt.display();
q.display();
umaAmostra.display();
variasAmostras.display();
fluxoContinuo.display();
//== mostrar o dtReal, tTotalRea e o erro
textAlign(LEFT);
if (dtErro){ fill(255,0,0); } else {fill(0,20,0); }
String tex="Real: dt"+dtReal.printV()+"s";
if (fluxoContinuo.clicado==false){
tex+=" total"+tTotalReal.printV()+"s";
}
text(tex,pnlAmostra.x+5,pnlAmostra.y+pnlAmostra.h-2);
fill(0);
pnlRC.display();
RC.display();
pnlSinal.display();
sinal.display();
fSinal.display();
tSinal.display();
tonSinal.display();
//=== se DEMO estiver ativado, então, gerar os dados ===
if (demo[0].clicado){
float mf=second()/10; // de 10 em 10 segundos faz multiplos da frequencia mf*freq
for (int k=0; k<q.v.v; k++){
canal[0].buffer[k]=(int)(512.0*(1+sin(2.0*PI*fSinal.v.v*((float)k*dt.v.v))));
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))));
canal[2].buffer[k]=(canal[0].buffer[k]+canal[1].buffer[k])/2;
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)))));
}
fase1+=2*PI/100;
canal[0].atualizou=true;
canal[1].atualizou=true;
canal[2].atualizou=true;
canal[3].atualizou=true;
} else if (demo[1].clicado){
float qmax=1/(fSinal.v.v*2*dt.v.v);
float qmin=qmax*tonSinal.v.v/100.0;
float qc=0.0;
float fator=0;
float vq=0;
float f0=(fase1/(2.0*PI*fSinal.v.v*dt.v.v))%qmax;
float f1=((fase1+radians(120))/(2.0*PI*fSinal.v.v*dt.v.v))%qmax;
float f2=((fase1+radians(240))/(2.0*PI*fSinal.v.v*dt.v.v))%qmax;
for (int k=0; k<q.v.v; k++){
qc=k % qmax;
if (qc<qmin) fator=0; else fator=1.0;
t2=((float)k+f0) % qmax;
if (t2<qmin) vq=0; else vq=1.0;
canal[0].buffer[k]=(int)(vq*512.0*(sin(fase1+2.0*PI*fSinal.v.v*((float)k*dt.v.v))));
canal[3].buffer[k]=(int)(vq*1023.0);
t2=((float)k+f1)%qmax;
if (t2<qmin) vq=0; else vq=1.0;
canal[1].buffer[k]=(int)(vq*512.0*(sin(fase1+radians(120)+2.0*PI*fSinal.v.v*((float)k*dt.v.v))));
t2=((float)k+f2)%qmax;
if (t2<qmin) vq=0; else vq=1.0;
canal[2].buffer[k]=(int)(vq*512.0*(sin(fase1+radians(240)+2.0*PI*fSinal.v.v*((float)k*dt.v.v))));
}
canal[0].atualizou=true;
canal[1].atualizou=true;
canal[2].atualizou=true;
canal[3].atualizou=true;
} else if (demo[2].clicado){
float qmax=1.0/(2*dt.v.v*fSinal.v.v);
float qmin=qmax*tonSinal.v.v/100.0;
float qc=0.0;
float fator=0;
for (int k=0; k<q.v.v; k++){
qc=k % qmax;
if (qc<qmin) fator=1; else fator=0;
canal[0].buffer[k]=(int)(fator*1023.0);
if (qc<qmin) {
canal[1].buffer[k]=(int)(512.0*(1.0-exp(-qc*100.0*dt.v.v)));
} else {
canal[1].buffer[k]=(int)(512.0*(exp(-(qc-qmin+1)*100.0*dt.v.v)));
}
canal[2].buffer[k]=(int)(512.0+512.0*(sin(radians(240)+2.0*PI*fSinal.v.v*((float)k*dt.v.v))));
canal[3].buffer[k]=(int)(fator*512.0*(sin(2.0*PI*fSinal.v.v*((float)k*dt.v.v))));
}
fase1+=2*PI/100;
canal[0].atualizou=true;
canal[1].atualizou=true;
canal[2].atualizou=true;
canal[3].atualizou=true;
}
}
void mouseClicked() {
//-- verificar se é para abrir Serial --
int r=com.mouseClicado();
if (r==1) { // retornou 1 então abrir serial
try {
//port=new Serial(this,com.ports[com.indPort],int(com.speeds[com.indSpeed]));
port=new Serial(this, com.ports[com.indPort], int(com.speeds[com.indSpeed]));
port.bufferUntil(10); //configurado para pegar linhas inteiras
com.conectado=true;
com.erro=false;
}
catch(Exception e) {
println("erro abrindo Serial:", e);
com.conectado=false;
com.erro=true;
}
if (com.conectado){ // start default was placed when eventSerial receives >init=v1.5
/*
//initProgram();
println("init delay 5000");
delay(5000);
println("end delay 5000");
for (int k=0;k<4;k++){
canal[k].chN.clicado=true;
}
// ligar uma amostra
variasAmostras.clicado=true;
if (variasAmostras.clicado) {
port.write("vo");
} else {
port.write("vx");
}
println("Abri Serial");
println("variasAmostra.clicado=",variasAmostras.clicado);
*/
}
} else if (r==-1) { //retornou -1 então fechar serial
port.stop();
com.conectado=false;
com.versionArduino.tex="";
com.erro=false;
}
if (resetEixos.mouseClicado()){
for (int k=0; k<4;k++){
canal[k].p0=tela.y+3*Q*(k+1);//posição da tensão zero
}
resetEixos.clicado=false;
}
if (resetMedir.mouseClicado()){
for (int k=0; k<4;k++){
canal[k].telaClicou=false;
}
resetMedir.clicado=false;
}
/*
if (XYZ.mouseClicado()) {
if (XYZ.clicado) {
canal[0].chN.clicado=true;
canal[1].chN.clicado=false;
canal[2].chN.clicado=false;
canal[3].chN.clicado=false;
} else {
canal[1].chN.clicado=true;
canal[2].chN.clicado=true;
canal[3].chN.clicado=true;
}
}
*/
chXYZ.mouseClicado();
//XYZ.mouseClicado();
// canais selecionados do XYZ
/*
for (int k=0;k<3;k++){
if(selXYZ[k].mouseClicado()){
int j=10-4-(parseInt(selXYZ[0].tex)+parseInt(selXYZ[1].tex)+parseInt(selXYZ[2].tex));
selXYZ[k].tex=str(j);
selXYZ[k].cor_ativo=cor[j];
selXYZ[k].clicado=true;
}
}
*/
// habilitar XYZ
//XYZ.mouseClicado();
for (int k=0; k<4; k++) {
if (canal[k].mouseClicado()){ // se alterou o Chn para visível ou não visível
if (com.conectado){ // enviar comando para o Arduino não ler esse canal
if (canal[k].chN.clicado){
port.write("c"+str(k)+"o");
} else {
port.write("c"+str(k)+"x");
}
}
verificarQ();
}
}
for (int k=0; k<3;k++){
if (demo[k].mouseClicado()) { // Acionar o DEMO e desmarcas os outros 2
if (demo[k].clicado) {
int total=0;
for (int k2=0; k2<3;k2++){
if (demo[k2].clicado) total++;
}
if (total<=1) {
tonSinal.salvar();
fSinal.salvar();
tSinal.salvar();
}
for (int j=0; j<k; j++) {
demo[j].clicado=false;
}
for (int j=2; j>k; j--) {
demo[j].clicado=false;
}
tonSinal.alterar=altMove;
fSinal.alterar=altMove;
tSinal.alterar=altMove;
} else {
tonSinal.restaurar();
tonSinal.alterar=altSolta;
fSinal.restaurar();
fSinal.alterar=altSolta;
tSinal.restaurar();
tSinal.alterar=altSolta;
}
}
}
// botões para medir tempo x tensão nos 4 canais (e botão de limpar x)
/*
for (int k=0;k<5;k++){
if (medir[k].mouseClicado()){
if (medir[k].clicado){
for (int j=0; j<k;j++){
medir[j].clicado=false;
}
for (int j=3;j>k;j--){
medir[j].clicado=false;
}
}
if (k==4){ // limpar os retangulos
for (int i=0; i<4; i++){
canal[i].telaClicou=false;
}
}
}
}
*/
// botões para acionar o trigger nos canais
/*
for (int k=0;k<5;k++){
if (trigger[k].mouseClicado()){
if (trigger[k].clicado){
for (int j=0; j<k;j++){
trigger[j].clicado=false;
}
for (int j=4;j>k;j--){
trigger[j].clicado=false;
}
//enviar comando para o Arduino
if (com.conectado) {
port.write("t"+trigger[k].tex);
}
} else{
if (com.conectado){
port.write("tx");
}
}
}
}
*/
verPontos.mouseClicado();
calcFreq.mouseClicado();
grafDif.mouseClicado();
//08-Jun-2017 write data to file
if (save.mouseClicado()){
// 14-Jun-2017 save fluxo or save memory
//println("fluxoContinuo.clicado=",fluxoContinuo.clicado);
if (fluxoContinuo.clicado){
if (outputOpen==false){ // não está gravando, então iniciar a gravação
//println("outputOpen==false => ",outputOpen);
String fileName ="dataf"+nf(year(),4)+nf(month(),2)+nf(day(),2)+nf(hour(),2)+nf(minute(),2)+nf(second(),2)+".txt";
output=createWriter(fileName);
outputOpen=true;
save.tex="salvando";
// cabeçalho
//output.println("BegOscopio v"+versao+" "+nf(year())+"-"+nf(month())+"-"+nf(day())+" "+nf(hour())+":"+nf(minute())+":"+nf(second()));
output.print("dt(");output.print(dt.v.printV());output.print(dt.unidade);output.print(")");
for (int k=0; k<4; k++){
if (canal[k].chN.clicado){
output.print('\t');output.print("ch");output.print(k);output.print("(mV)");
}
}
output.println();
qSave=0;
// ao entrar cada dado no fluxo gravar em output.print()
// gravar na rotina de entrada
} else { // save já está gravando, então parar a gravação
//println("outputOpen==true => ",outputOpen);
output.close();
outputOpen=false;
qSave=1;
if (qSave>10) {qSave=1;}
save.tex="salvar datax.txt" + "-"+qSave;
save.clicado=false;
}
} else {
String fileName ="data"+nf(year(),4)+nf(month(),2)+nf(day(),2)+nf(hour(),2)+nf(minute(),2)+nf(second(),2)+".txt";
output=createWriter(fileName);
// cabeçalho
//output.println("BegOscopio v"+versao+" "+nf(year())+"-"+nf(month())+"-"+nf(day())+" "+nf(hour())+":"+nf(minute())+":"+nf(second()));
output.print("dt(");output.print(dt.v.printV());output.print(dt.unidade);output.print(")");
for (int k=0; k<4; k++){
if (canal[k].chN.clicado){
output.print('\t');output.print("ch");output.print(k);output.print("(mV)");
}
}
output.println();
// dados
float f=5000.0/1023.0;
for (int k2=0; k2<q.v.v;k2++){
output.print(k2);
for (int k=0; k<4; k++) {
if (canal[k].chN.clicado){
output.print('\t');output.print(int(canal[k].v[k2]*f));
}
}
output.println();
}
output.close();
qSave+=1;
if (qSave>10) {qSave=1;}
save.tex="salvar datax.txt" + "-"+qSave;
save.clicado=false;
}
}
//ruido.mouseClicado();
//se clicou em dt ou q então enviar comando para Arduino e ajustar tela
if (dt.mouseClicado()) { // se true alterou dt, então ajustarFt() (escala de t na tela)
enviarDt();
ajustarFt();
}
if (q.mouseClicado()) { // se true alterou q, então ajustarFt()
enviarQ();
ajustarFt();
}
if (RC.mouseClicado()) {
if (com.conectado) {
if (RC.clicado) {
port.write("ro");
} else {
port.write("rx");
RC.tex2="";
}
} else {
RC.clicado=false;
}
}
if (umaAmostra.mouseClicado()) { // receber apenas Uma Amostra
variasAmostras.clicado=false;
fluxoContinuo.clicado=false;
if (outputOpen) {
fecharDados();
}
if (com.conectado) {
port.write("1");
}
umaAmostra.clicado=false;
// verificar se tem algum trigger acionado para que ele fique esperando o disparo
// vai ficar piscando para indicar que está aguardando o disparo.
int k2=-1;
for (int k=0; k<4;k++){
if (canal[k].trigger.clicado) {
k2=k;
break;
}
}
//println("k2=",k2);
if (k2>=0 && k2<=3){
pnlAmostra.piscar=true;
canal[k2].trigger.piscar=true;
esperandoTrigger=true;
} else {
pnlAmostra.piscar=false;
esperandoTrigger=false;
}
}
if (variasAmostras.mouseClicado()) {
umaAmostra.clicado=false;
fluxoContinuo.clicado=false;
if (outputOpen) {
fecharDados();
}
if (com.conectado) {
if (variasAmostras.clicado) {
port.write("vo");
} else {
port.write("vx");
}
} else {
variasAmostras.clicado=false;
}
}
if (fluxoContinuo.mouseClicado()) {
umaAmostra.clicado=false;
variasAmostras.clicado=false;
if (com.conectado) {
if (fluxoContinuo.clicado) {
port.write("fo");
} else {
port.write("fx");
if (outputOpen){
fecharDados();
}
}
} else {
fluxoContinuo.clicado=false;
}
}
if (sinal.mouseClicado()){
if (com.conectado){
if (sinal.clicado){
port.write("so");
} else {
port.write("sx");
}
}
}
if (fSinal.mouseClicado()){
tSinal.setV(1/fSinal.v.v);
enviarCmd("tSinal");
}
if (tSinal.mouseClicado()){
fSinal.setV(1/tSinal.v.v);
enviarCmd("tSinal");
}
if (tonSinal.mouseClicado()){
enviarCmd("tonSinal");
}
}
void verificarQ(){
chq=0; // contar qtd de canais ativos
for (int k=0; k<4; k++){
if (canal[k].chN.clicado){
chq+=1;
}
}
//q.vMax=408.0/chq;
switch (chq){
case 0:
q.vMax=0;
break;
case 1:
q.vMax=400;
break;
case 2:
q.vMax=200;
break;
case 3:
q.vMax=130;
break;
case 4:
q.vMax=100;
break;
}
if (q.v.v>q.vMax) {
q.setV(q.vMax);
ajustarFt();
} else {
q.setV(q.v.v);
}
}
void mousePressed() {
//d.mousePressionou();
for (int k=0; k<4; k++) {
canal[k].mousePressionou();
}
chXYZ.mousePressionou();
dt.mousePressionou();
q.mousePressionou();
//ruido.mousePressionou();
// só para aparecer o verde do pressionado
umaAmostra.mousePressionou();
variasAmostras.mousePressionou();
fluxoContinuo.mousePressionou();
fSinal.mousePressionou();
tSinal.mousePressionou();
tonSinal.mousePressionou();
for (int k=0; k<3;k++){
demo[k].mousePressionou();
}
resetEixos.mousePressionou();
resetMedir.mousePressionou();
}
void mouseReleased() {
// d.mouseSoltou();
for (int k=0; k<4; k++) {
canal[k].mouseSoltou();
}
chXYZ.mouseSoltou();
for (int k=0; k<3;k++){
demo[k].mouseSoltou();
}
resetEixos.mouseSoltou();
resetMedir.mouseSoltou();
// só para aparecer o verde do pressionado
umaAmostra.mouseSoltou();
variasAmostras.mouseSoltou();
fluxoContinuo.mouseSoltou();
//se soltar o mouse no dt ou q, então enviar os dados para o Arduino
if (dt.mouseSoltou()) {
enviarDt();
ajustarFt();
}
if (q.mouseSoltou()) {
enviarQ();
// acertar as escalas ft de cada canal
ajustarFt();
}
//ruido.mouseSoltou();
if (fSinal.mouseSoltou()) {
tSinal.setV(1/fSinal.v.v);
enviarCmd("tSinal");
}
if (tSinal.mouseSoltou()) {
fSinal.setV(1/tSinal.v.v);
enviarCmd("tSinal");
}
if (tonSinal.mouseSoltou()){
enviarCmd("tonSinal");
}
// controle do y do XYZ
//if (XYZ.clicado){
// XYZyPegou=false;
//}
}
void mouseMoved() {
//teste
// canal[0].cor=get(mouseX,mouseY);
// println("cor=",canal[0].cor);
com.mouseMoveu();
for (int k=0; k<4; k++) {
canal[k].mouseMoveu();
}
chXYZ.mouseMoveu();
dt.mouseMoveu();
q.mouseMoveu();
//ruido.mouseMoveu();
fSinal.mouseMoveu();
tSinal.mouseMoveu();
tonSinal.mouseMoveu();
}
void mouseDragged() {
//d.mouseArrastou();
for (int k=0; k<4; k++) {
canal[k].mouseArrastou();
}
chXYZ.mouseArrastou();
dt.mouseArrastou();
q.mouseArrastou();
//ruido.mouseArrastou();
if (fSinal.alterar==altSolta){
fSinal.mouseArrastou();
tSinal.mouseArrastou();
} else {
if (fSinal.mouseArrastou()){
tSinal.setV(1/fSinal.v.v);
}
if (tSinal.mouseArrastou()){
fSinal.setV(1/tSinal.v.v);
}
}
tonSinal.mouseArrastou();
// controle do y do XYZ
//if (XYZ.clicado){
// if (XYZyPegou){
// XYZy=constrain(mouseY,tela.y,tela.y+10*Q)-mouseOffSet;
// }
//}
}
void keyReleased(){
keyPressed=false;
}
void fecharDados(){
output.close();
outputOpen=false;
if (qSave>10) {qSave=1;}
save.tex="salvar datax.txt" + "-"+qSave;
save.clicado=false;
}
/* ==========================================
Comando enviados para o Arduino
========================================== */
//=== Ger.Sinal - Se alterou f/T/Ton - enviar comando para Arduino ==
void enviarCmd(String cmd){
if (cmd.equals("tSinal")){
if (com.conectado){
port.write("p"+tSinal.v.printV());
println("p"+tSinal.v.printV());
}
} else if (cmd.equals("tonSinal")){
if (com.conectado){
port.write("o"+tonSinal.v.printV()+"%");
println("o"+tonSinal.v.printV()+"%");
}
}
}
//==Se alterou dt ou q enviar comando para Arduino e ajustar a escala da tela ==
void enviarDt() {
if (com.conectado) {
port.write("d"+dt.v.printV());
}
// acertar as escalas ft de cada canal
ajustarFt();
}
void enviarQ() {
if (com.conectado) {
port.write("q"+q.v.printV()+".");
}
}
void ajustarFt() {
float ftNew=dt.v.getV()*q.v.getV()/10.0;
println("ftNew=",ftNew," dt=",dt.v.getV()," q=",q.v.getV());
for (int k=0; k<4; k++) {
canal[k].ft.setV(ftNew);
}
}
/*=====================================
Entrada do Evento Porta Serial
=====================================*/
void serialEvent(Serial p) {
//if (p.available()>0) {}
try {
String cmd="", val="";
String tex=p.readStringUntil(10);
//print(">>>> ",tex); //eliminar
if (tex.charAt(0)=='>') { //comando: >cmd=v1(tab)v2(tab)v3(tab)
int i=tex.indexOf("=");
if (i>=0) { // encontrou sinal "=" (igual) obs: i=-1 => não encontrou o sinal '='
cmd=tex.substring(1, i); // pegar o comando obs: substring(inclusive,exclusive)
val=tex.substring(i+1); // pegar o valor
//println("cmd=",cmd," val=",val);
if (cmd.equals("init")) { // init
println("versionArduino=<",val,">");
com.versionArduino.tex=".ino "+val.substring(0,val.length()-1);
//start all channels
for (int k=0;k<4;k++){
canal[k].chN.clicado=true;
}
// enviar dt
enviarDt();
// verificar e enviar q
verificarQ();
enviarQ();
// send command to Arduino -> start Signal Gennerator 60Hz tOn25%
enviarCmd("tSinal");
enviarCmd("tonSinal");
sinal.clicado=true;
port.write("so");
// ligar varias amostra
variasAmostras.clicado=true;
port.write("vo");
//if (variasAmostras.clicado) {
// port.write("vo");
// } else {
// port.write("vx");
// }
println("Abri Serial");
println("variasAmostra.clicado=",variasAmostras.clicado);
} else if (cmd.equals("f")) { // entra fluxo de dados - deslocar dados e armazenar no final
String tex2[]=splitTokens(val); //val = "0(t)dtReal(t)ch0(t)ch1(t)ch2"
//deslocar os dados para baixo, para incluir o novo dado no final
for (int j=0; j<4; j++) {
for (int k=1; k<q.v.v; k++) {
canal[j].v[k-1]=canal[j].v[k];
}
}
canal[0].v[int(q.v.v-1)]=int(tex2[2]);
canal[1].v[int(q.v.v-1)]=int(tex2[3]);
canal[2].v[int(q.v.v-1)]=int(tex2[4]);
canal[3].v[int(q.v.v-1)]=int(tex2[5]);
dtReal.setV(float(tex2[1]));
if (dtReal.v-dt.v.v>1.1*dt.v.v){ dtErro=true;} else {dtErro=false;}
// salvar em arquivo
if (outputOpen) {
float f=5000.0/1023.0;
//for (int k2=0; k2<q.v.v;k2++){
int k2=int(q.v.v-1);
output.print(qSave);
qSave+=1;
for (int k=0; k<4; k++) {
if (canal[k].chN.clicado){
output.print('\t');output.print(int(canal[k].v[k2]*f));
}
}
output.println();
if (qSave % 100==0) { // de 100 em 100
save.tex="salvando "+nf(qSave);
output.flush();
}
//}
}
//println("cmd=",cmd," val=",val," dtReal=",dtReal.printV());
} else if (cmd.equals("chq")) { // entra qtd e quais canais serão recebidos
int v[]=int(splitTokens(val));
//voltar // println("========================");
//voltar // println("cmd=",cmd," val=",val);
chq=v[0];
for (int k=0;k<chq;k++){
ch[k]=v[k+1];
}
//voltar // println("chs=",chq);
for (int k=0;k<chq;k++){
//voltar // println("ch[",k,"]=",ch[k]);
}
//voltar // println("========================");
} else if (cmd.equals("v")) { // entrada de Varias Amostra
int v[]=int(splitTokens(val));
//voltar // println("tex=",tex);
//println("cmd=",cmd," val=",val);
//println("v.length=",v.length," chq=",chq);
//for (int k=0; k<v.length; k++){
// print(" v[",k,"]=",v[k]);
//}
//println("");
if (v.length==chq+1){ // >v=1 1024 100 300 300
for (int k=0; k<chq; k++){
canal[ch[k]].buffer[v[0]]=v[k+1];
}
}
/*
int kk=v[0]; // indice da matriz
canal[0].buffer[v[0]]=v[1];
canal[1].buffer[v[0]]=v[2];
canal[2].buffer[v[0]]=v[3];
canal[3].buffer[v[0]]=v[4];
*/
} else if (cmd.equals("q")) { // quantidade de variaveis
// q.setV(float(val));
} else if (cmd.equals("dt")) { // tamanho do dt (ms)
//dt.val=float(val);
} else if (cmd.equals("tTotalReal")) { // tempo total da amostra
//println("atualizou");
tTotalReal.setV(float(val));
//text(tTotalReal,pnlAmostra.x+2,pnlAmostra.y+pnlAmostra.h);
//voltar // println("cmd=",cmd," val=",val," tTotalReal=",tTotalReal.printV());
canal[0].atualizou=true; // terminou de entrar os dados então
canal[1].atualizou=true; // carregar do buffer
canal[2].atualizou=true;
canal[3].atualizou=true;
if (esperandoTrigger){
esperandoTrigger=false;
pnlAmostra.piscar=false;
for (int k=0; k<4;k++){
canal[k].trigger.piscar=false;
}
}
} else if (cmd.equals("dtReal")){
dtReal.setV(float(val));
if (dtReal.n>dt.v.n+10){ dtErro=true;} else {dtErro=false;}
//text(dtReal,pnlAmostra.x+2,pnlAmostra.y+pnlAmostra.h-12);
//voltar // println("cmd=",cmd," val=",val," dtReal=",dtReal.printV());
} else if (cmd.equals("r") || cmd.equals("c") || cmd.equals("rc")) { // valor do resistor
String tex2[]=splitTokens(val, "\t\r");
//i=val.indexOf("\t");
//for (int k=0; k<tex2.length; k++){
// print("tex2[",k,"]=",tex2[k]);
//}
//println();
if (cmd.equals("rc")) cmd="";
RC.tex2=cmd.toUpperCase()+" "+tex2[1]+" ("+tex2[0]+")";
} else if (cmd.charAt(0)=='?') { // carregando as configurações do Arduino (ao conectar)
cmd=cmd.substring(2); // eliminar 2 caracteres iniciais "? comando"
val=val.substring(0,val.length()-2); // eliminar 2 caracteres finais: \n\r(13,10)(^M^J) (retorno de linha)
//voltar // println("cmd=",cmd," val=",val);
if (cmd.equals("q")){ // val=100
q.v.v=float(val);
} else if (cmd.equals("dt")){
char unid=val.charAt(val.length()-2);
val=val.substring(0,val.length()-2);
//voltar // println("unid=",unid," val=",val);
if (unid=='u'){
val=val+"e-6";
}else{
val=val+"e-3";
}
//voltar // println("val=",val);
dt.setV(float(val));
ajustarFt();
}else if (cmd.equals("canalTrigger")){ // val= 0,1,2,x
for (int k=0;k<4;k++){canal[k].trigger.clicado=false;}
if (!val.equals("x")){
canal[int(val)].trigger.clicado=true;
}
} else if (cmd.equals("uma")){ // val= 0 ou 1
//umaAmostra.clicado=boolean(int(val));
}else if (cmd.equals("varias")){ // val= 0 ou 1
//variasAmostras.clicado=boolean(int(val));
}else if (cmd.equals("fluxo")){ // val= 0 ou 1
fluxoContinuo.clicado=boolean(int(val));
}else if (cmd.equals("lerRC")){ // val= 0 ou 1
RC.clicado=boolean(int(val));
}else if (cmd.equals("pwmOn")){ // val=0 ou 1 (false/true)
sinal.clicado=boolean(int(val));
//println("sinal.clicado=",sinal.clicado," val=",val," boolean(val)=",boolean(val));
//for (int k=0; k<val.length();k++){
// println(k," - ",val.charAt(k)," - ",byte(val.charAt(k)));
//}
//println("int(val)=",int(val)," int(''0'')",int("0")," int(''1'')",int(1));
//println("b(''0'')=",boolean("0")," b(''1'')=",boolean("1")," b('0')=",boolean('0')," b('1')=",boolean('1'));
}else if (cmd.equals("pwmP")){ // cmd="pwmP", val=" 100000us"
val=val.substring(0,val.length()-2)+"e-6"; // remover "us" e colocar "e-6" (microsegundos)
tSinal.setV(float(val));
fSinal.setV(1/tSinal.v.v);
//println("pwmP=",float(val));
}else if (cmd.equals("pwmPon")){ // cmd="pwmPon", val="25%"
val=val.substring(0,val.length()-1);
tonSinal.setV(float(val));
//voltar // println("pwmPon=",float(val));
}else {
print("else >>>> ",tex);
}
}
}
//println("cmd=",cmd);
//println("val=",val);
}
}
catch(RuntimeException e){
e.printStackTrace();
}
}

复制代码

* Processing 版本3.5.3