public/logic-analyzer
1
0
Fork 0
mirror of https://github.com/aster94/logic-analyzer.git synced 2026-05-01 15:10:43 +03:00
Code Issues Packages Projects Releases Wiki Activity

Added the modifications to work on arduino UNO

Browse Source 
almost the same features for arduino MEGA, now for arduino UNO!
This commit is contained in:
sancho11
2019-01-12 02:05:43 -06:00
parent 0b87ec4e7a
commit df602c7423
2 changed files with 993 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

854
Computer_Interface/processing_for_UNO_newmod.pde Normal file
View File

@@ -0,0 +1,854 @@
import processing.serial.*;
import java.util.Arrays;
Serial p;
////////////////////////////////////////////////
/*--------------------SETUP-------------------*/
//uncomment the line where your arduino/STM32 is connected
//String LA_port = "/dev/ttyACM0"; //linux DFU
//String LA_port = "/dev/ttyUSB0"; //linux Serial
String LA_port = "COM3"; //windows
final int baudrate = 115200; //check if it is the same in arduino
/*------------------END SETUP-----------------*/
////////////////////////////////////////////////
//colors:
int white = 255;
int black = 0;
int green = #00FF00;
int red = #FF0000;
int grey = 150;
// shift, reducer and millisecond view
float reducer = 1.0;
boolean milliseconds = true;
float xShift;
// start point in the processing window
float xEdge = 60;
float yEdge = 10;
float xEnd;
float oldxEnd;
float[] xPos = new float[16];
float yBottom;
float yDiff;
float yPos = yEdge;
float ySave = yEdge;
boolean textCovered;
boolean drawTimes = true;
//Serial from mcu
//initial data
int samples;
int event;
int initialState[]= new int[3];
boolean first = false;
boolean dataComplete = false;
//following data
boolean [][][] state;
boolean [][] isLow = new boolean[8][3];
boolean [][] isLowinit = new boolean[8][3];
float[] usTime;
float[] xTime;
int[][] pinChanged;
int[] PinAssignment = new int[16];
int[] PinArduinoNames = new int[16];
int index1;
int index2;
int index3;
boolean refresh= true;
int []cursora= new int[2];
float cursoraf= 0;
boolean cursorplay=false;
/*
ENGLISH
How the assign of the pins works?.
The entries will be depleted in the order they appear in the whole PinAssignment that goes from 0 to 15 for a total of 16, the value of the integer in each position will
reference the pin to be used. Then the value that must be entered in the integer will be shown to observe the desired pin.
In case you do not want to show anything on that channel, just assign 00 so that the channel will not be written.
The pins that do not appear in the table can not be used because they were not considered in the arduino programming, to avoid overloading the
arduino and obtain more satisfactory response times.
SPANISH
Funcionamiento de la asignacion de pines.
Las entradas se deplegaran en el orden que aparezcan en el entero PinAssignment que va del 0 al 15 para un total de 16, el valor del entero en cada posicion referenciara
el pin a utilizar. A continuacion se mostrara el valor que se debe introducir en el entero para observar el pin deseado.
En caso de no querer mostrar nada en ese canal basta con asignar 00 para que el canal no sea escrito.
Los pines que no aparecen en la tabla no podrán ser utilizados por que no fueron considerados en la programacion de arduino, esto para evitar sobrecargar al
arduino y obtener tiempos de respuesta más satisfactorios.
EN Number of Pin in the Arduino UNO Number to enter in the PinAssignment
ES Numero de Pin en el Arduino UNO Numero a introducir en el PinAssignment
Digital PIN 8 -------------------------------------------------------> 10
Digital PIN 9 -------------------------------------------------------> 11
Digital PIN 10 -------------------------------------------------------> 12
Digital PIN 11 -------------------------------------------------------> 13
Digital PIN 12 -------------------------------------------------------> 14
Digital PIN 13 -------------------------------------------------------> 15
*/
//buttons and others
int button1X = 8;
int button2X = 8;
int button3X = 80;
int button4X = 200;
int button5X = 270;
int buttonY;
int buttonH = 20;
int smallButtonW = 50;
int bigButtonW = 100;
int graphBoxH;
int textBoxH;
int immage = 1;
int corner = 10;
String s;
boolean initial=true;
// bar scroll
int handleFill = grey;
float handleX;
float handleY;
float handleW = 20;
float handleH = 15;
boolean isDraggable = false;
void setup () {
//p = new Serial(this, Serial.list()[0], 115200);
p = new Serial(this, LA_port, baudrate);
p.bufferUntil('\n');
size(1300, 700);
background(black);
smooth(4);
xShift=(width-handleW)/2;
//Here you chose the pins that yuo want to show in the Logic Analizer. Put 00 to OFF the channel.
//Aquí escoges los pines que quieres desplegar.
PinAssignment[0] = 10;
PinAssignment[1] = 11;
PinAssignment[2] = 12;
PinAssignment[3] = 13;
PinAssignment[4] = 14;
PinAssignment[5] = 15;
PinAssignment[6] = 00;
PinAssignment[7] = 00;
PinAssignment[8] = 00;
PinAssignment[9] = 00;
PinAssignment[10]= 00;
PinAssignment[11]= 00;
PinAssignment[12]= 00;
PinAssignment[13]= 00;
PinAssignment[14]= 00;
PinAssignment[15]= 00;
for (int i=0; i<16; i++) {
switch (PinAssignment[i]) {
case (10):
PinArduinoNames[i]=08;
break;
case (11):
PinArduinoNames[i]=09;
break;
case (12):
PinArduinoNames[i]=10;
break;
case (13):
PinArduinoNames[i]=11;
break;
case (14):
PinArduinoNames[i]=12;
break;
case (15):
PinArduinoNames[i]=13;
break;
default:
PinArduinoNames[i]=00;
break;
}
}
graphBoxH = height -50;
textBoxH = height - 35;
yBottom = graphBoxH-20;
buttonY = textBoxH +8;
handleX = xEdge;
handleY = graphBoxH;
}
void cleanGraph() {
noStroke(); //no borders
fill(black);
rect(xEdge, 0, width, graphBoxH); //cancel the graph
stroke(green); //green lines
Arrays.fill(xPos, 0); //reset start point of the graph
textCovered = false;
}
void draw() {
if (dataComplete==true) {
cleanGraph();
pushMatrix(); //move the coordinate reference
translate(xEdge, 0);
float firstchange;
boolean cares;
if (cursorplay){
fill(50);
stroke(75);
if(cursora[1]==16){ //Esta variable la utilizamos para definir el canal sobre el cual estamos trabajando, en esta parte marcamos el rectangulo en el que trabajamos.
rect(0, yBottom-12, width-xEdge, 34);
}
else{
rect(0, yEdge+36*cursora[1]-2, width-xEdge, 34);
}
stroke(green);
}
updatepos(); //Se encarga de decir que segmento de tiempos se va a escribir
for (int i=0; i<samples; i++) {
cares=false;
firstchange=0;
yPos = yEdge; //start a new cicle
// println();
for (int n=0; n<16; n++) {
if (PinAssignment[n] != 0){
s = str(PinAssignment[n]);
index1 = s.charAt(1)-'0';
index2 = s.charAt(0)-'1';
//printArray(state[0][0]);
// print(state[i][index1][index2]+" , ");
if (state[i][index1][index2]) {
cares=true;
if(firstchange==0){
firstchange=yPos;
}
ySave = yPos; //save y value
if (i==0){
if (isLowinit[index1][index2]) { //pin high else low //<>//
yDiff=yPos;
yPos+=30;
} else {
yDiff=yPos+30;
}
isLow[index1][index2]=isLowinit[index1][index2];
//println(isLowinit[index1][index2]);
}
else {
if (isLow[index1][index2]) { //pin high else low
yDiff=yPos;
yPos+=30;
isLow[index1][index2]=false;
} else {
yDiff=yPos+30;
isLow[index1][index2]=true;
}
}
// Graph lines
line(xPos[n]+xShift, yPos, xTime[i]+xShift, yPos); // straight line
line(xTime[i]+xShift, yPos, xTime[i]+xShift, yDiff); // vertical line
xPos[n]=xTime[i]; //save last position of the line for the pin
yPos = ySave; //load the initial value of the y
}
}
yPos+=36; //go to the next pin
}
// Text times
if ((drawTimes && cares)||i==0) {
if (cursora[0]==i){
stroke(red);
fill(red);
}else{
stroke(grey);
fill(grey);
}
textSize(10);
textCovered=!textCovered;
dashline(xTime[i]+xShift, firstchange, xTime[i]+xShift, yBottom, spacing);
text(round(usTime[i]), xTime[i]+xShift+2, (textCovered==true) ? yBottom : yBottom+10); //write on different height
stroke(green);
}
}
yPos = yEdge;
for (int n = 0; n < 16; n++) {
if (PinAssignment[n]!=0){
s= str(PinAssignment[n]);
index1 = s.charAt(1)-'0';
index2 = s.charAt(0)-'1';
if (xPos[n]==0) {
if (isLowinit[index1][index2]==true) line(xPos[n]+xShift, yPos+30, xEnd+xShift, yPos+30);
else line(xPos[n]+xShift, yPos, xEnd+xShift, yPos);
}
}
yPos+=36;
}
dataComplete = false;
popMatrix();
}
drawText();
}
void drawText() {
stroke(white); //white borders
fill(black);
rect(0, 0, xEdge, graphBoxH); //clean left side
rect(xEdge, graphBoxH, width, handleH); //clean bar scroll
rect(0, textBoxH, width, height); //clean bottom side
// write name of the pins
fill(white);
textSize(14);
int x=5;
int y=30;
/* if (STM32) {
for (byte i = 12; i<=15; i++) {
line(x, y-20, xEdge, y-20);
line(x, y+10, xEdge, y+10);
text ("PB"+i, x, y);
y+=60;
}
} else {
*/
for (byte i = 0; i<16; i++) {
line(x, y-20, xEdge, y-20);
line(x, y+10, xEdge, y+10);
stroke(#EF7F1A);
dashline(xEdge, y-23 , width, y-23, spacingnew);
dashline(xEdge, y+13 , width, y+13, spacingnew);
stroke(white);
if (PinArduinoNames[i]==0){
text ("Pin "+ "OFF", x, y);}
else{
text ("Pin "+ str(PinArduinoNames[i]), x, y);
}
y+=36;
}
// draw buttons
fill(grey);
rect(button1X, yBottom-15, smallButtonW, buttonH, corner);
rect(button2X, buttonY, smallButtonW, buttonH, corner);
rect(button3X, buttonY, bigButtonW, buttonH, corner);
rect(button4X, buttonY, smallButtonW, buttonH, corner);
rect(button5X, buttonY, smallButtonW, buttonH, corner);
fill(white);
text("Start", button2X+3, buttonY+14);
text(reducer, button4X, buttonY+14);
text("Save", button5X+3, buttonY+14);
text(milliseconds == true ? "milliseconds" : "microseconds", button3X+3, buttonY+14);
text("T:"+ str (drawTimes), button1X+3, yBottom);
//bar scroll
fill(handleFill);
rect(handleX, handleY, handleW, handleH);
if (isDraggable) {
handleX = mouseX-handleW/2;
if (handleX<xEdge) handleX = xEdge;
if (handleX>width-handleW) handleX = width-handleW;
updatepos();
dataComplete = true;
}
}
void mousePressed() {
if (mouseX>xEdge && mouseX<width &&
mouseY>handleY && mouseY<handleY+handleH) {
isDraggable = true;
handleFill = color(100, 200, 255);
}
}
void getCursora(int index){
cursoraf=-(xShift-mouseX+xEdge);
cursora[1]=index;
println (xTime[samples-1]);
println (cursoraf);
if (index!=16){
s = str(PinAssignment[index]);
index1 = s.charAt(1)-'0';
index2 = s.charAt(0)-'1';
cursora[0]=0; //Lleva registros del evento en el que estamos
// println (abs(xTime[46]+xShift));
if (cursoraf<0 ||cursoraf>xTime[samples-1]){
if (cursoraf<=0){
cursora[0]=0;
}
if (cursoraf>=xTime[samples-1]){
cursora[0]=samples-1;
}
}else{
for (int i=1; i<samples-1;i++){
//if (abs(xTime[i]-cursoraf)>abs(xTime[i+1]-cursoraf)&&state[i][index1][index2]){
if (abs(xTime[i]-cursoraf)>abs(xTime[i+1]-cursoraf)){
if(state[i][index1][index2]){
cursora[0]=i;
}
}else {
break;
}
//println (abs(xTime[i]+xShift));
//println ("wut");
}
}
}
println( cursora[0]);
dataComplete=true;
}
void updatepos(){
if (samples!=0) {
xEnd = (xTime[samples-1]);
// xEnd = xEnd
} else {
xEnd = 0;
}
xShift = -map(handleX, xEdge, width-handleW, 0, xEnd);
xShift = xShift + (width-handleW)/2;
}
void movepos(){
xShift = xTime[cursora[0]];
handleX = map(xShift, 0, xEnd, xEdge, width-handleW);
xShift = -xShift - (width-handleW)/2;
dataComplete=true;
}
void keyPressed() {
int number;
if (key == CODED) {
if (keyCode == UP && cursorplay) {
number=cursora[1];
cursora[1]= cursora[1]-1;
for (int i=cursora[1]; i>=0; i--){
if (PinAssignment[cursora[1]]==0){
cursora[1]= cursora[1]-1;
}else {
break;
}
}
if (cursora[1]==-1){
cursora[1]= number;
}
cursora[1]=constrain(cursora[1], 0, 16);
//println("cur1 "+cursora[1]+"cur0 "+cursora[0]);
dataComplete=true;
} else if (keyCode == DOWN && cursorplay) {
if(cursora[1]<16){
cursora[1]= cursora[1]+1;
for (int i=cursora[1]; i<16; i++){
if (PinAssignment[cursora[1]]==0){
cursora[1]= cursora[1]+1;
}else {
break;
}
cursora[1]=constrain(cursora[1], 0, 16);
} }
//println("cur1 "+cursora[1]+"cur0 "+cursora[0]);
dataComplete=true;
} else if (keyCode == RIGHT && cursorplay) {
if (cursora[1]==16){
if (cursora[0]!=samples-1){
cursora[0]+=1;
}
}
else{
s = str(PinAssignment[cursora[1]]);
index1 = s.charAt(1)-'0';
index2 = s.charAt(0)-'1';
//println(cursora[0]);
for (int i=cursora[0]+1; i<samples; i++){
cursora[0]=i;
if (state[i][index1][index2]){
break;
}else {
}
}}
//updatepos();
movepos();
}else if (keyCode == LEFT && cursorplay) {
//println(cursora[0]);
if (cursora[1]==16){
if (cursora[0]!= 0){
cursora[0]-=1;
}
}
else{
s = str(PinAssignment[cursora[1]]);
index1 = s.charAt(1)-'0';
index2 = s.charAt(0)-'1';
for (int i=cursora[0]-1; i>-1; i--){
cursora[0]=i;
if (state[i][index1][index2]){
break;
}else {
} }
}
//println("cur1 "+cursora[1]+"cur0 "+cursora[0]);
//updatepos();
movepos();
}else if (keyCode == LEFT && !cursorplay) {
handleX-=1;
if (handleX<xEdge) handleX = xEdge;
if (handleX>width-handleW) handleX = width-handleW;
dataComplete=true;
}else if (keyCode == RIGHT && !cursorplay) {
handleX+=1;
if (handleX<xEdge) handleX = xEdge;
if (handleX>width-handleW) handleX = width-handleW;
dataComplete=true;
}
}
}
void mouseClicked() {
// bootons over signals
if(mouseX>xEdge && mouseX <width && mouseY>yBottom-15 && mouseY <yBottom-15+buttonH){
getCursora(16); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge && mouseY <yEdge+30 && PinAssignment[0]!=0){getCursora(0); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36 && mouseY <yEdge+36+30 && PinAssignment[1]!=0){getCursora(1); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*2 && mouseY <yEdge+36*2+30 && PinAssignment[2]!=0){getCursora(2); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*3 && mouseY <yEdge+36*3+30 && PinAssignment[3]!=0){getCursora(3); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*4 && mouseY <yEdge+36*4+30 && PinAssignment[4]!=0){getCursora(4); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*5 && mouseY <yEdge+36*5+30 && PinAssignment[5]!=0){getCursora(5); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*6 && mouseY <yEdge+36*6+30 && PinAssignment[6]!=0){getCursora(6); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*7 && mouseY <yEdge+36*7+30 && PinAssignment[7]!=0){getCursora(7); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*8 && mouseY <yEdge+36*8+30 && PinAssignment[8]!=0){getCursora(8); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*9 && mouseY <yEdge+36*9+30 && PinAssignment[9]!=0){getCursora(9); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*10 && mouseY <yEdge+36*10+30 && PinAssignment[10]!=0){getCursora(10); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*11 && mouseY <yEdge+36*11+30 && PinAssignment[11]!=0){getCursora(11); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*12 && mouseY <yEdge+36*12+30 && PinAssignment[12]!=0){getCursora(12); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*13 && mouseY <yEdge+36*13+30 && PinAssignment[13]!=0){getCursora(13); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*14 && mouseY <yEdge+36*14+30 && PinAssignment[14]!=0){getCursora(14); cursorplay=true; movepos();
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*15 && mouseY <yEdge+36*15+30 && PinAssignment[15]!=0){getCursora(15); cursorplay=true; movepos();}
else
// draw times
if (mouseY>yBottom-15 && mouseY <yBottom-15+buttonH &&
mouseX>button1X && mouseX <button1X+smallButtonW) {
drawTimes = !drawTimes;
refresh=true;
}else
// new read
if (mouseY>buttonY && mouseY <buttonY+buttonH &&
mouseX>button2X && mouseX <button2X+smallButtonW) {
refresh=true;
p.write('G');
println("new data coming");
p.clear();
xShift = (width-handleW)/2;
handleX = xEdge;
} else
//save frame
if (mouseY>buttonY && mouseY <buttonY+buttonH &&
mouseX>button5X && mouseX <button5X+smallButtonW) {
String a = "la_capture-"+immage; //+".jpg"; //if you prefer this format, default .tif
save(a);
immage++;
} else
//change scalar
if (mouseY>buttonY && mouseY <buttonY+buttonH &&
mouseX>button4X && mouseX <button4X+smallButtonW) {
if (mouseButton == LEFT){
//it is over the reducer button
if (reducer<1){
reducer+= 0.1;
}else if (reducer<10){
reducer+=1;
}else {
reducer+=10;
}
if (reducer>90 && !milliseconds){
reducer=0.1;
milliseconds = !milliseconds;
}
reducer = constrain(reducer, 0.1, 100);
} else { //move the graph
if (reducer<=1){
reducer-= 0.1;
}else if (reducer<=10){
reducer-=1;
}else {
reducer-=10;
}
if (reducer<0.1 && milliseconds){
reducer=100;
milliseconds = !milliseconds;
}
reducer = constrain(reducer, 0.1, 90);
}
scaletime();
updatepos();
dataComplete=true;
} else
// micro or millis
if (mouseY>buttonY && mouseY <buttonY+buttonH &&
mouseX>button3X && mouseX <button3X+bigButtonW) {
milliseconds = !milliseconds;
scaletime();
dataComplete=true;
// updatepos();
}
else{cursorplay=false;
dataComplete=true;}
}
void mouseReleased() {
isDraggable = false;
handleFill = grey;
if (refresh){
//scaletime('d');
//xShift = -map(handleX, xEdge, width-handleW, 0, xEnd);
//xShift = xShift + (width-handleW)/2;
refresh=false;
//updatepos();
//dataComplete=true;
}
}
void mouseWheel(MouseEvent event) {
float wheel = event.getCount();
//move the graph
handleX-=wheel*50;
if (handleX<xEdge) handleX = xEdge;
if (handleX>width-handleW) handleX = width-handleW;
dataComplete=true;
}
void mouseMoved() {
if (mouseY>buttonY && mouseY <buttonY+buttonH && mouseX>button2X && mouseX <button2X+smallButtonW) {
cursor(HAND);
} else if (mouseY>buttonY && mouseY <buttonY+buttonH && mouseX>button3X && mouseX <button3X+bigButtonW) {
cursor(HAND);
} else if (mouseY>buttonY && mouseY <buttonY+buttonH && mouseX>button5X && mouseX <button5X+smallButtonW) {
cursor(HAND);
} else if (mouseY>buttonY && mouseY <buttonY+buttonH && mouseX>button4X && mouseX <button4X+smallButtonW) {
cursor(HAND);
}else if (mouseY>yBottom-15 && mouseY <yBottom-15+buttonH && mouseX>button1X && mouseX <button1X+smallButtonW) {
cursor(HAND);
} else if (mouseX>handleX && mouseX<handleX+handleW && mouseY>handleY && mouseY<handleY+handleH) {
cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yBottom-15 && mouseY <yBottom-15+buttonH){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge && mouseY <yEdge+30 && PinAssignment[0]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36 && mouseY <yEdge+36+30 && PinAssignment[1]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*2 && mouseY <yEdge+36*2+30 && PinAssignment[2]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*3 && mouseY <yEdge+36*3+30 && PinAssignment[3]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*4 && mouseY <yEdge+36*4+30 && PinAssignment[4]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*5 && mouseY <yEdge+36*5+30 && PinAssignment[5]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*6 && mouseY <yEdge+36*6+30 && PinAssignment[6]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*7 && mouseY <yEdge+36*7+30 && PinAssignment[7]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*8 && mouseY <yEdge+36*8+30 && PinAssignment[8]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*9 && mouseY <yEdge+36*9+30 && PinAssignment[9]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*10 && mouseY <yEdge+36*10+30 && PinAssignment[10]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*11 && mouseY <yEdge+36*11+30 && PinAssignment[11]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*12 && mouseY <yEdge+36*12+30 && PinAssignment[12]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*13 && mouseY <yEdge+36*13+30 && PinAssignment[13]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*14 && mouseY <yEdge+36*14+30 && PinAssignment[14]!=0){cursor(HAND);
} else if(mouseX>xEdge && mouseX <width && mouseY>yEdge+36*15 && mouseY <yEdge+36*15+30 && PinAssignment[15]!=0){cursor(HAND);
} else {
cursor(ARROW);
}
}
void serialEvent (Serial p) { //Recupera los datos recibidos desde el arduino, y hace uso de la funcion get data para pasarlos de datos almacenados en 3bytes a matrices para utilizarlos facilmente
String inString = p.readStringUntil('\n');
inString = trim(inString);
println("incoming: "+inString);
if (inString.equals("S")) {
initialState[0] = 0;
initialState[1] = 0;
initialState[2] = 0;
samples=0;
event=-2;
first = true;
} else {
String list [] = split(inString, ':');
String sublistate [] = split(list[0], ',');
if (first == true) {
initialState[0] = int (sublistate[0]);
initialState[1] = int (sublistate[1]);
initialState[2] = int (sublistate[2]);
samples = int (list[1]);
pinChanged = new int[samples][3];
usTime = new float[samples];
xTime = new float[samples];
state = new boolean[samples][8][3];
first = false;
} else {
pinChanged[event][0] = int (sublistate[0]);
pinChanged[event][1] = int (sublistate[1]);
pinChanged[event][2] = int (sublistate[2]);
usTime[event] = float (list[1]);
}
}
event++;
if (event == samples) {
getData();
}
}
void scaletime() { //Poner una r indicara que la funcion solo va a rehacer los tiempos.
if (milliseconds){
for (int i = 0; i < samples; i++) {
xTime[i] = usTime[i] / (reducer*1000); //better to reduce the lenght of the x
}
}
else {
for (int i = 0; i < samples; i++) {
xTime[i] = usTime[i] / reducer; //better to reduce the lenght of the x
}
}
}
void getData () {
scaletime();
//check data:
println("event: "+event);
print("initial: "+initialState[0]);
print(","+initialState[1]);
println(","+initialState[2]);
println("samples: "+samples);
//println("time"+usTime[0]);
//printArray(pinChanged[0]);
//printArray(xTime);
//println("pin: "+binary(changed[0], 6));
int mask = 1;
// initial state
for (int n=0; n<8; n++) {
isLow[n][0] = !boolean (initialState[0] & mask);
isLow[n][1] = !boolean (initialState[1] & mask);
isLow[n][2] = !boolean (initialState[2] & mask);
isLowinit[n][0] = !boolean (initialState[0] & mask); //No se sí al simplemente hacer las asignaciones se pase el dato o todo el puntero asi que no me la quiero jugar
isLowinit[n][1] = !boolean (initialState[1] & mask);
isLowinit[n][2] = !boolean (initialState[2] & mask);
mask <<= 1;
//println("islow: "+isLow[n]);
}
// changes
for (int i=0; i<samples; i++) {
mask = 1;
//println("i:"+i);
//println(binary(changed[i], 6));
for (int n=0; n<8; n++) {
state[i][n][0]= boolean (pinChanged[i][0] & mask);
state[i][n][1]= boolean (pinChanged[i][1] & mask);
state[i][n][2]= boolean (pinChanged[i][2] & mask);
mask <<= 1;
//print(state[i][n][0]+" , "+state[i][n][1]+" , "+state[i][n][2]);
//println();
}
//println();
}
dataComplete = true;
}
float[] spacing = {5, 8}; //used for the dashline function, pixels
float[] spacingnew = {1, 50}; //used for the dashline function, pixels
void dashline(float x0, float y0, float x1, float y1, float[] spacing) {
float distance = dist(x0, y0, x1, y1);
float [ ] xSpacing = new float[spacing.length];
float [ ] ySpacing = new float[spacing.length];
float drawn = 0.0; // amount of distance drawn
if (distance > 0)
{
int i;
boolean drawLine = true; // alternate between dashes and gaps
/*
Figure out x and y distances for each of the spacing values
I decided to trade memory for time; I'd rather allocate
a few dozen bytes than have to do a calculation every time
I draw.
*/
for (i = 0; i < spacing.length; i++)
{
xSpacing[i] = lerp(0, (x1 - x0), spacing[i] / distance);
ySpacing[i] = lerp(0, (y1 - y0), spacing[i] / distance);
}
i = 0;
while (drawn < distance)
{
if (drawLine)
{
line(x0, y0, x0 + xSpacing[i], y0 + ySpacing[i]);
}
x0 += xSpacing[i];
y0 += ySpacing[i];
/* Add distance "drawn" by this line or gap */
drawn = drawn + mag(xSpacing[i], ySpacing[i]);
i = (i + 1) % spacing.length; // cycle through array
drawLine = !drawLine; // switch between dash and gap
}
}
}

139
Microcontroller_Code/UNO/UNO_newmod.ino Normal file
View File

@@ -0,0 +1,139 @@
/*
* UNO.ino
*
* Created: 11/12/2016 19.35.51
* Author : Vincenzo
* Led on A0
*/
#define baudrate 115200 // check if it is the same in processing
#define samples 200 // the number of samples you want to take
#define timezerooffset 125 //microsegundos
#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#define prescaler 0x02
volatile uint16_t timer1_overflow_count;
uint8_t initial, state, old_state;
uint8_t pinChanged[samples];
uint32_t timer[samples];
uint32_t timefix;
uint16_t event = 0;
void init_board() {
PORTC = (0 << 0); DDRC |= (1 << 0); // led A0
DDRB |= 0x00; // pin 8-13 input
PORTB |= 0x3F; // pull-up
}
void init_timer() {
//clear
TCCR1A = 0b00000000;
TCCR1B = 0b00000000;
TIMSK1 = 0b00000000;
//settings
TCCR1A |= (0 << COM1A1) | (0 << COM1A0) | (0 << COM1B1) | (0 << COM1B0); //normal port operation
TCCR1A |= (0 << WGM11) | (0 << WGM10); //normal operation
TCCR1B |= (0 << WGM13) | (0 << WGM12); //normal operation
TCCR1B |= prescaler; //(0 << CS12) | (0 << CS11) | (1 << CS10); //clock prescaler
sei(); //enable interrupts
TIMSK1 |= (1 << TOIE1); // enable overflow interrupt
}
ISR(TIMER1_OVF_vect) {
timer1_overflow_count++;
}
void reset_timer1 () {
TCNT1 = 0;
timer1_overflow_count = 0;
}
uint32_t myMicros () {
cli();
if (TIFR1 & (1 << TOV1)) {
TIFR1 = (0 << TOV1);
timer1_overflow_count++;
}
uint32_t total_time = (65536 * timer1_overflow_count + TCNT1) / 2;
sei();
return total_time;
}
void start() {
_delay_ms(1000);
reset_timer1();
event = 0;
PORTC = (1 << 0);
initial = PINB;
state = initial;
for (int i=0; i < samples; i++) {
pinChanged[i]=0;
}
}
void sendData() {
PORTC = (0 << 0); //turn off led
//initial data
Serial.println("S");
Serial.print(initial); Serial.print(','); Serial.print(B11111111); Serial.print(','); Serial.print(B11111111); Serial.print(":");
Serial.println(samples+3);
timefix = -timer[0]+timezerooffset;
for (int i = 0; i < samples; i++) {
timer[i]=timer[i]+timefix;
}
Serial.print(B11111111);Serial.print(','); Serial.print(B11111111); Serial.print(','); Serial.print(B11111111); Serial.print(":");//Este segmento de codigo introduce un cambio en todos los
Serial.println(0); //canales, lo que soluciona un error en el codigo en processing
Serial.print(B11111111);Serial.print(','); Serial.print(B11111111); Serial.print(','); Serial.print(B11111111); Serial.print(":");//al final se hace un cambio en todos los canales, lo que soluciona
Serial.println(1); //otro pequeño fallo visual.
//data
for (int i = 0; i < samples; i++) {
Serial.print(pinChanged[i]);Serial.print(','); Serial.print(B00000000); Serial.print(','); Serial.print(B00000000); Serial.print(":");
Serial.println(timer[i]);
}
Serial.print(B11111111);Serial.print(','); Serial.print(B11111111); Serial.print(','); Serial.print(B11111111); Serial.print(":");
Serial.println((timer[samples-1]+400));
}
int main(void) {
Serial.begin(baudrate);
init_board();
init_timer();
start();
while (1) {
old_state = state;
state = PINB;
if (old_state != state) {
timer[event] = myMicros();
pinChanged[event] = state ^ old_state;
event++;
if (event == samples) {
sendData();
while (Serial.read() != 'G') ; //wait for the "go"
start();
}
}
}
}