Buggfix Plus
Aktuellt datum och tid: 08.18 2019-11-14

Alla tidsangivelser är UTC + 1 timme




Svara på tråd  [ 49 inlägg ]  Gå till sida Föregående  1, 2, 3, 4
Författare Meddelande
InläggPostat: 11.34 2019-07-28 
Användarvisningsbild

Blev medlem: 18.04 2009-08-16
Inlägg: 11056
Buffrade bilder och Canvas fungerar inte riktigt bra så därför
lät jag klassen Graph att utöka från klassen JComponent som
är en lättviktigare komponent.

Det fungerar alldeles förträffligt bra att nu dra i en slider för att
justera en marker. Sedan kan jag finjustera med en spinner.

När jag drar i slidern så ändras värdet i spinnern och tvärt om.
Det är spinnern som har händelsehanteraren och ritar om de
buffrade bilderna med uppdaterade värden för markeringslinjerna
och tillhörande värden som syns, och följer med, linjerna.

På något sätt tänkte jag inkludera en graf i NTC-interfacet så jag måste
då också lösa hur jag ska få axlarna att graderas riktigt beroende på
vilken kurva jag får. Max y-värde ges ju av kurvans formel och max x-värde
av mellan vilka motståndsvärden kurvan ritas.

Kod: [Expandera/Minimera] [Hämta] (Untitled.txt)
import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Point2D;
import javax.swing.JComponent;

public class Graph extends JComponent {
   private static final long serialVersionUID = 1L;
   public static final int AXIS_MARGIN = 68;         // totala marginalen ovan+under och vänster+höger
   public static final int HALF_AXIS_MARGIN = AXIS_MARGIN/2;
   public static final int X_MARKERS_SPACE = 20;      // antal pixlar mellan varje markör på x-axeln
   public static final int Y_MARKERS_SPACE = 10;      // sätter steglängden hos markörer
   public static final int MARKER_LENGTH = 1;         // markörernas halva längd
   public static final double SCALEFACTOR_Y = 100.0;   // y-axeln ska visa 100ggr mindre värden än dess längd i pixlar   
   private int jComponentWidth;
   private int jComponentHeight;
   private ImageA imgA;
   private ImageB imgB;
   private static Point2D origo;
   private Graphics2D g;
   private int markerLineX1pos;
   private int markerLineY1pos;
   private int markerLineX2pos;
   private int markerLineY2pos;
   private AlphaComposite compA;
   private AlphaComposite compB;
   private int yAxisStart;
   private int xAxisStart;
   private int xAxisEnd;   
   private int yAxisEnd;
   private String sY1;
   private String sY2;
   private String sX1;
   private String sX2;
   private Font f;
   /*
    * Konstruktor. Skapar en JComponent med höjd, bredd och placeras
    * med offset i x- och y-led i den behållare där den ingår.
    * Buffrade bilder placeras sedan på denna JComponent.
    */
   public Graph(int offsetX, int offsetY,int width, int height) {
      jComponentWidth = width;
      jComponentHeight = height;
      setBackground(Color.WHITE);
      setBounds(offsetX, offsetY, width, height);
      imgA = new ImageA(jComponentWidth,jComponentHeight,Color.WHITE);                    // skapa en buffrad bild med x-y-axel
      imgB = new ImageB(jComponentWidth-AXIS_MARGIN,jComponentHeight-AXIS_MARGIN,Color.WHITE); // skapa en buffrad bild med plottad funktion
      markerLineX1pos = markerLineX2pos = (int) origo.getX();
      markerLineY1pos = markerLineY2pos = (int) origo.getY();      
      compA = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f);   // genomskinlighetsgrad
      compB = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f);
      yAxisStart = (int) origo.getY();
      xAxisStart = (int) origo.getX();
      xAxisEnd = jComponentWidth - HALF_AXIS_MARGIN;
      yAxisEnd =  HALF_AXIS_MARGIN;
      sY1 = sX1 = sY2 = sX2 = Double.toString(0.0);                  // utgångsläge för markörer X1,Y1,X2,Y2
      f = new Font("SansSerif",Font.BOLD,12);                        // text/font markörvärde label
   }
   public void paint(Graphics gr) {
      super.paint(gr);      
      g = (Graphics2D) gr;
      g.setFont(f);
      g.setComposite(compA);
      g.drawImage(imgA, null, 0, 0);                           // rita den buffrade bilden                     
      g.setComposite(compB);   
      g.drawImage(imgB, null, xAxisStart ,HALF_AXIS_MARGIN);         // rita den buffrade bilden
      drawMarkerLineX1(markerLineX1pos);                         // rita en flyttbar x-markering i JComponent
      drawMarkerLineY1(markerLineY1pos);                        // rita en flyttbar y-markering i JComponent
      drawMarkerLineX2(markerLineX2pos);                         // rita en flyttbar x-markering i JComponent
      drawMarkerLineY2(markerLineY2pos);                        // rita en flyttbar y-markering i JComponent
      g.dispose();
   }
   /*
    * Ritar en lodrät markeringslinje i grafen på angiven X1-koordinat.
    */
   private void drawMarkerLineX1(int x) {
      g.setPaint(Color.BLUE);
      sX1 = Double.toString(x-Graph.HALF_AXIS_MARGIN);
      g.drawString(sX1, x+3, yAxisEnd+10);                     // rita en label med aktuellt X1-värde
      g.drawLine(x, HALF_AXIS_MARGIN, x, yAxisStart);
   }
   /*
    * Ritar en lodrät markeringslinje i grafen på angiven X2-koordinat.
    */
   private void drawMarkerLineX2(int x) {
      g.setPaint(Color.ORANGE);
      sX2 = Double.toString(x-Graph.HALF_AXIS_MARGIN);
      g.drawString(sX2, x+3, yAxisEnd+21);                     // rita en label med aktuellt X2-värde
      g.drawLine(x, HALF_AXIS_MARGIN, x, yAxisStart);
   }
   /*
    * Ritar en vågrät markeringslinje i grafen på angiven Y1-koordinat.
    */
   private void drawMarkerLineY1(int y) {
      g.setPaint(Color.BLUE);
      sY1 = Double.toString((yAxisStart-y)/SCALEFACTOR_Y);
      g.drawString(sY1, xAxisEnd-10, y-3);                     // rita en label med aktuellt Y1-värde
      g.drawLine(HALF_AXIS_MARGIN, y, xAxisEnd, y);
   }
   /*
    * Ritar en vågrät markeringslinje i grafen på angiven Y2-koordinat.
    */
   private void drawMarkerLineY2(int y) {
      g.setPaint(Color.ORANGE);
      sY2 = Double.toString((yAxisStart-y)/SCALEFACTOR_Y);
      g.drawString(sY2, xAxisEnd-35, y-3);                     // rita en label med aktuellt Y2-värde
      g.drawLine(HALF_AXIS_MARGIN, y, jComponentWidth - HALF_AXIS_MARGIN, y);
   }
   
   /*
    * Flyttar/uppdaterar y-koordinaten för den vågräta markeringslinjen Y1
    * Händelsehanterare i GUI aktiverar denna metod
    */
   public void setMarkerLineY1pos(int y) {
      markerLineY1pos= yAxisStart - y;
      repaint();
   }
   /*
    * Flyttar/uppdaterar y-koordinaten för den vågräta markeringslinjen Y2
    * Händelsehanterare i GUI aktiverar denna metod
    */
   public void setMarkerLineY2pos(int y) {
      markerLineY2pos= yAxisStart - y;
      repaint();
   }
   /*
    * Flyttar/uppdaterar x-koordinaten för den lodräta markeringslinjen X1
    * Händelsehanterare i GUI aktiverar denna metod
    */
   public void setMarkerLineX1pos(int x) {
      markerLineX1pos= x + xAxisStart;
      repaint();
   }
   /*
    * Flyttar/uppdaterar x-koordinaten för den lodräta markeringslinjen X2
    * Händelsehanterare i GUI aktiverar denna metod
    */
   public void setMarkerLineX2pos(int x) {
      markerLineX2pos= x + xAxisStart;
      repaint();
   }

   public static void setOrigo(Point2D origo) {
      Graph.origo = origo;
   }
   public static Point2D getOrigo() {
      return origo;
   }
}


Kod: [Expandera/Minimera] [Hämta] (Untitled.txt)
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.geom.AffineTransform;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
/*
 * Skapar en buffrad bild som ligger i botten av ett lager med flera bilder.
 * Bilden består av en färgad rektangel som det går att rita i.
 * Denna basbild innehåller en skalad x- och y-axel.
 */
public class ImageA extends BufferedImage {
   private Graphics2D g;
   private Rectangle2D rek;
   private int jComponentWidth;
   private int jComponentHeight;
   private int xAxisLength;
   private int yAxisLength;
   private int xAxisStart;
   private int xAxisEnd;
   private int yAxisStart;
   private int yAxisEnd;
   private Point2D xEnd;
   private Point2D yEnd;
   private Point2D origo;
   private int numberOfxMarkers;
   private int numberOfyMarkers;
   public ImageA(int width, int height, Color color) {
      super(width, height, BufferedImage.TYPE_INT_ARGB);
      jComponentWidth = width;
      jComponentHeight = height;      
      g = this.createGraphics();
      g.setStroke(new BasicStroke(1.0f));
      rek = new Rectangle2D.Double(0,0,width,height);
      g.setPaint(color);
      g.fill(rek);
      g.draw(rek);
      g.setPaint(Color.BLACK);
      drawAxis();
      drawMarkers();
      g.dispose();
   }
   /*
    * Ritar markeringar med jämna mellanrum på de båda axlarna.
    *
    */
   private void drawMarkers() {
      numberOfxMarkers = xAxisLength/Graph.X_MARKERS_SPACE;
      numberOfyMarkers = yAxisLength/Graph.Y_MARKERS_SPACE;
      int dx = xAxisLength/numberOfxMarkers;
      int dy = yAxisLength/numberOfyMarkers;
      int xs = xAxisStart;
      int xe = xAxisEnd;
      int ys = yAxisStart;
      int ye = yAxisEnd;
      Font font = new Font("SansSerif", Font.PLAIN, 14);
      AffineTransform affineTransform = new AffineTransform();
      affineTransform.rotate(Math.toRadians(90), 0, 0);      
      Font rotatedFont = font.deriveFont(affineTransform);
      g.setFont(rotatedFont);
      for(int i=xs;i<=xe;i+=dx) {      // börja rita x-markörer från origo
         drawXMarker(i,(i-xs));
      }
      font = new Font("SansSerif", Font.PLAIN, 11);
      affineTransform = new AffineTransform();
      affineTransform.rotate(Math.toRadians(0), 0, 0);      
      rotatedFont = font.deriveFont(affineTransform);
      g.setFont(rotatedFont);
      for(int i=ys;i>=ye;i-=dy) {      // börja rita y-markörer från origo
         drawYMarker(i,(ys-i)/Graph.SCALEFACTOR_Y);
      }
   }
   /*
    * Ritar markörer utmed x-axeln på de positioner som anges av
    * parametern xpos.
    */
   private void drawXMarker(int xpos,double scaleNumber) {
      String s = String.valueOf((int)scaleNumber);
      Point xm1 = new Point(xpos,(int)origo.getY()+Graph.MARKER_LENGTH);
      Point xm2 = new Point(xpos,(int)origo.getY()-Graph.MARKER_LENGTH);
      Line2D.Double marker = new Line2D.Double(xm1,xm2);
      g.draw(marker);
      drawXScale(s,xpos-3,(int)(origo.getY()+5));
   }
   /*
    * Ritar markörer utmed y-axeln på de positioner som anges av
    * parametern ypos.
    */
   private void drawYMarker(int ypos, double scaleNumber) {
      String s = String.valueOf(scaleNumber);
      Point ym1 = new Point((int)origo.getX()-Graph.MARKER_LENGTH,ypos);
      Point ym2 = new Point((int)origo.getX()+Graph.MARKER_LENGTH,ypos);
      Line2D.Double marker = new Line2D.Double(ym1,ym2);
      g.draw(marker);
      drawYScale(s,(int)(origo.getX()),ypos);
   }
   /*
    * Graderar x-axeln med tal
    */
   private void drawXScale(String s, int xpos, int ypos) {   
      g.setPaint(Color.BLUE);
      g.drawString(s, xpos-1, ypos+1);
   }
   /*
    * Graderar y-axeln med tal
    */
   private void drawYScale(String s, int xpos, int ypos) {   
      g.setPaint(Color.RED);
      g.drawString(s, xpos-20, ypos+3);
   }
   /*
    * Ritar de två axlarna med origo i sydväst.
    * Axlarnas längd i pixlar begränsas av JComponent:ens höjd och bredd och
    * den valda marginalen från dess ytterkanter till där axlarna ritas.
    */
   private void drawAxis() {
      xAxisLength = jComponentWidth - Graph.AXIS_MARGIN;            
      yAxisLength = jComponentHeight- Graph.AXIS_MARGIN;            
      xAxisStart = jComponentWidth - xAxisLength - Graph.HALF_AXIS_MARGIN;    
      yAxisEnd = jComponentHeight - yAxisLength - Graph.HALF_AXIS_MARGIN;                                 
      yAxisStart = jComponentHeight - Graph.HALF_AXIS_MARGIN;      
      xAxisEnd = xAxisLength + xAxisStart;
      Graph.setOrigo(new Point(xAxisStart,yAxisStart));
      origo = Graph.getOrigo();
      xEnd = new Point(xAxisEnd,yAxisStart);
      yEnd = new Point(xAxisStart,yAxisEnd);
      Line2D.Double xAxel = new Line2D.Double(origo,xEnd);
      Line2D.Double yAxel = new Line2D.Double(origo, yEnd);
      g.draw(xAxel);
      g.draw(yAxel);
   }
}


Kod: [Expandera/Minimera] [Hämta] (Untitled.txt)
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
/*
 * Skapar en buffrad bild.
 * Bilden består av en färgad rektangel som det går att rita i.
 * Denna bild innehåller en plottad kurva.
 */
public class ImageB extends BufferedImage {
   private Graphics2D g;
   private Rectangle2D rek;
   private Point2D origo;
   public ImageB(int width, int height, Color color) {
      super(width, height, BufferedImage.TYPE_INT_ARGB);
      origo = Graph.getOrigo();
      g = this.createGraphics();
      g.setStroke(new BasicStroke(1.0f));
      rek = new Rectangle2D.Double(0,0,width,height);
      g.setPaint(color);
      g.fill(rek);   
      g.draw(rek);
      g.setPaint(Color.BLACK);
      plotFunction(SwingWindow.A,SwingWindow.B,SwingWindow.C);      // funktionskonstanter hämtas från main-klassen
      g.dispose();
   }
   /*
    * Ritar en funktion y(x) i x-y-grafen. y(x) = a + bx + cx^2
    * y = 2.31 - 0.0047*R + 1.93*10^-6*R^2
    *
    */
   private void plotFunction(double a, double b, double c) {
      double x1 = 0;
      double y1 = 0;
      double x2 = 0;
      double y2 = 0;   
      while(y2>=0) {      
         y2 = (a + b*x2 + c*Math.pow(x2, 2))*100;
         g.drawLine(x(x1), y(y1), x(x2), y(y2));
         x1 = x2;
         y1 = y2;
         x2 = x2+1;
      }
   }
   /*
    * Parametern x refererar till en x-koordinat med ett origo som har x=0 och y=0
    * Returnerar den absoluta x-koordinaten i förhållande till det origo
    * som ritats i canvas med de faktiska x- och y-koordinaterna.
    */
   private int x(double x) {
      return (int)(origo.getX()+x-Graph.AXIS_MARGIN/2);
   }
   /*
    * Parametern y refererar till en y-koordinat med ett origo som har x=0 och y=0
    * Returnerar den absoluta y-koordinaten i förhållande till det origo
    * som ritats i canvas med de faktiska x- och y-koordinaterna.
    */
   private int y(double y) {
      return (int)(origo.getY()-y-Graph.AXIS_MARGIN/2);
   }

}

Kod: [Expandera/Minimera] [Hämta] (Untitled.txt)
import javax.swing.JFrame;
import java.awt.SystemColor;
import javax.swing.JButton;
import javax.swing.Box;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.EventQueue;
import javax.swing.JSpinner;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.event.ChangeListener;
import javax.swing.event.ChangeEvent;
import java.awt.Color;
import javax.swing.SpringLayout;
import javax.swing.SpinnerNumberModel;
import javax.swing.JSlider;

public class SwingWindow extends JFrame {
   
   private static final long serialVersionUID = 1L;
   public final int WINDOW_WIDTH = 800;
   public final int WINDOW_HEIGHT = 520;
   public static final int JC_WIDTH = 772;
   public static final int JC_HEIGHT = 365;
   public final int SPINNER_X_STARTVALUE = 0;
   public final int SPINNER_Y_STARTVALUE = 0;
   // y = 2.31 - 0.0047*x + 1.93*10^-6*x^2
   public static final double A = 2.31;
   public static final double B = -0.0047;
   public static final double C = 0.00000193;
   private static JButton b0;
   private static JButton b1;
   private static JButton b2;
   private static JSpinner spinner_X1;
   private static JSpinner spinner_Y1;
   private static JSpinner spinner_X2;
   private static JSpinner spinner_Y2;
   private static int spinner_X1_value;
   private static int spinner_Y1_value;
   private static int spinner_X2_value;
   private static int spinner_Y2_value;

   private JSlider sliderX1;
   private JSlider sliderY1;
   private JSlider sliderX2;
   private JSlider sliderY2;

   private Graph graph;
   public static SwingWindow swingwindow;
   private Box horizontalBox;
   /**
    * Launch the application.
    */
   public static void main(String[] args) {
      //swingwindow = new SwingWindow();
      //swingwindow.setVisible(true);
      EventQueue.invokeLater(new Runnable() {
         public void run() {
            try {
               swingwindow = new SwingWindow();
               swingwindow.setVisible(true);
            } catch (Exception e) {
               e.printStackTrace();
            }
         }
      });    
   }

   /**
    * Create the application.
    */
   public SwingWindow() {
      super("Swing");   
      setMaximumSize(new Dimension(1000, 800));
      getContentPane().setBackground(new Color(240, 230, 140));
      getContentPane().setLayout(null);
      setBounds(400, 100, WINDOW_WIDTH, WINDOW_HEIGHT);
      setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);   
      setUpGUI();
   }
   /**
    * Initialize the contents of the frame.
    */
   private void setUpGUI() {      
      JPanel panel = new JPanel();
      panel.setBackground(SystemColor.menu);
      panel.setBounds(5, 376, 772, 100);
      getContentPane().add(panel);
      SpringLayout sl_panel = new SpringLayout();
      panel.setLayout(sl_panel);
      
      Box horizontalBox_1 = Box.createHorizontalBox();
      sl_panel.putConstraint(SpringLayout.WEST, horizontalBox_1, 10, SpringLayout.WEST, panel);
      sl_panel.putConstraint(SpringLayout.EAST, horizontalBox_1, -10, SpringLayout.EAST, panel);
      horizontalBox_1.setOpaque(true);
      sl_panel.putConstraint(SpringLayout.NORTH, horizontalBox_1, 11, SpringLayout.NORTH, panel);
      panel.add(horizontalBox_1);
      
      JLabel lblYMarker = new JLabel("Y1 marker");
      horizontalBox_1.add(lblYMarker);
      
      Component rigidArea = Box.createRigidArea(new Dimension(20, 20));
      rigidArea.setMinimumSize(new Dimension(15, 20));
      rigidArea.setPreferredSize(new Dimension(15, 20));
      rigidArea.setMaximumSize(new Dimension(15, 20));
      horizontalBox_1.add(rigidArea);
      
      spinner_Y1 = new JSpinner();
      spinner_Y1.setValue(0);
      spinner_Y1.setDoubleBuffered(true);
      spinner_Y1.setMinimumSize(new Dimension(15, 20));
      spinner_Y1.setPreferredSize(new Dimension(15, 20));
      spinner_Y1.addChangeListener(new ChangeListener() {
         public void stateChanged(ChangeEvent e) {
            spinner_Y1_value = (int) spinner_Y1.getValue();
            sliderY1.setValue(spinner_Y1_value);
            graph.setMarkerLineY1pos(spinner_Y1_value);
         }
      });
      horizontalBox_1.add(spinner_Y1);
      
      Component rigidArea_5 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_5.setMinimumSize(new Dimension(15, 20));
      rigidArea_5.setPreferredSize(new Dimension(15, 20));
      rigidArea_5.setMaximumSize(new Dimension(15, 20));
      horizontalBox_1.add(rigidArea_5);
      
      JLabel lblXMarker = new JLabel("X1 marker");
      horizontalBox_1.add(lblXMarker);
      
      Component rigidArea_1 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_1.setMinimumSize(new Dimension(15, 20));
      rigidArea_1.setPreferredSize(new Dimension(15, 20));
      rigidArea_1.setMaximumSize(new Dimension(15, 20));
      horizontalBox_1.add(rigidArea_1);
      
      spinner_X1 = new JSpinner();
      spinner_X1.setModel(new SpinnerNumberModel(0, 0, 700, 1));
      spinner_X1.setValue(0);
      spinner_X1.setDoubleBuffered(true);
      spinner_X1.setMinimumSize(new Dimension(15, 20));
      spinner_X1.setPreferredSize(new Dimension(15, 20));
      spinner_X1.addChangeListener(new ChangeListener() {
         public void stateChanged(ChangeEvent e) {
            spinner_X1_value = (int) spinner_X1.getValue();
            sliderX1.setValue(spinner_X1_value);
            graph.setMarkerLineX1pos(spinner_X1_value);
         }
      });
      horizontalBox_1.add(spinner_X1);
      
      Component rigidArea_8 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_8.setMinimumSize(new Dimension(15, 20));
      rigidArea_8.setPreferredSize(new Dimension(15, 20));
      rigidArea_8.setMaximumSize(new Dimension(15, 20));
      horizontalBox_1.add(rigidArea_8);
      
      JLabel lblXMarker_1 = new JLabel("Y2 marker");
      horizontalBox_1.add(lblXMarker_1);
      
      Component rigidArea_6 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_6.setMinimumSize(new Dimension(15, 20));
      rigidArea_6.setPreferredSize(new Dimension(15, 20));
      rigidArea_6.setMaximumSize(new Dimension(15, 20));
      horizontalBox_1.add(rigidArea_6);
      
      spinner_Y2 = new JSpinner();
      spinner_Y2.addChangeListener(new ChangeListener() {
         public void stateChanged(ChangeEvent e) {
            spinner_Y2_value = (int) spinner_Y2.getValue();
            sliderY2.setValue(spinner_Y2_value);
            graph.setMarkerLineY2pos(spinner_Y2_value);
         }
      });
      spinner_Y2.setDoubleBuffered(true);
      spinner_Y2.setMinimumSize(new Dimension(15, 20));
      spinner_Y2.setPreferredSize(new Dimension(15, 20));
      horizontalBox_1.add(spinner_Y2);
      
      Component rigidArea_7 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_7.setMinimumSize(new Dimension(15, 20));
      rigidArea_7.setPreferredSize(new Dimension(15, 20));
      rigidArea_7.setMaximumSize(new Dimension(15, 20));
      horizontalBox_1.add(rigidArea_7);
      
      JLabel lblXMarker_2 = new JLabel("X2 marker");
      horizontalBox_1.add(lblXMarker_2);
      
      Component rigidArea_9 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_9.setMinimumSize(new Dimension(15, 20));
      rigidArea_9.setPreferredSize(new Dimension(15, 20));
      rigidArea_9.setMaximumSize(new Dimension(15, 20));
      horizontalBox_1.add(rigidArea_9);
      
      spinner_X2 = new JSpinner();
      spinner_X2.addChangeListener(new ChangeListener() {
         public void stateChanged(ChangeEvent e) {
            spinner_X2_value = (int) spinner_X2.getValue();
            sliderX2.setValue(spinner_X2_value);
            graph.setMarkerLineX2pos(spinner_X2_value);
         }
      });
      spinner_X2.setDoubleBuffered(true);
      spinner_X2.setPreferredSize(new Dimension(15, 20));
      spinner_X2.setMinimumSize(new Dimension(15, 20));
      horizontalBox_1.add(spinner_X2);
      horizontalBox = Box.createHorizontalBox();
      sl_panel.putConstraint(SpringLayout.WEST, horizontalBox, 0, SpringLayout.WEST, horizontalBox_1);
      sl_panel.putConstraint(SpringLayout.EAST, horizontalBox, -10, SpringLayout.EAST, panel);
      panel.add(horizontalBox);
      
      b0 = new JButton("Plotta Kurva");
      b0.setDoubleBuffered(true);
      b0.setPreferredSize(new Dimension(130, 23));
      b0.setMaximumSize(new Dimension(130, 23));
      b0.addActionListener(new Listener().new PlotFunction());
      
      Component horizontalGlue = Box.createHorizontalGlue();
      horizontalBox.add(horizontalGlue);
      horizontalBox.add(b0);
      
      Component rigidArea_2 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_2.setMaximumSize(new Dimension(22, 20));
      rigidArea_2.setMinimumSize(new Dimension(22, 20));
      rigidArea_2.setPreferredSize(new Dimension(30, 20));
      horizontalBox.add(rigidArea_2);
      
      b1 = new JButton("Radera Kurva");
      b1.setDoubleBuffered(true);
      b1.setPreferredSize(new Dimension(130, 23));
      b1.setMaximumSize(new Dimension(130, 23));
      b1.addActionListener(new Listener().new Repaint());
      horizontalBox.add(b1);
      
      Component rigidArea_3 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_3.setMaximumSize(new Dimension(22, 20));
      rigidArea_3.setMinimumSize(new Dimension(22, 20));
      rigidArea_3.setPreferredSize(new Dimension(30, 20));
      horizontalBox.add(rigidArea_3);
      
      b2 = new JButton("------------");
      b2.setDoubleBuffered(true);
      b2.setPreferredSize(new Dimension(130, 23));
      b2.setMaximumSize(new Dimension(130, 23));
      // b2.addActionListener(new Listener().new Render());
      horizontalBox.add(b2);
      
      JButton b3 = new JButton("Avsluta");
      b3.setDoubleBuffered(true);
      b3.setMinimumSize(new Dimension(72, 23));
      b3.setPreferredSize(new Dimension(130, 23));
      b3.setMaximumSize(new Dimension(130, 23));
      b3.addActionListener(new Listener().new Avbryt());
      
      Component rigidArea_4 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_4.setMaximumSize(new Dimension(22, 20));
      rigidArea_4.setMinimumSize(new Dimension(22, 20));
      rigidArea_4.setPreferredSize(new Dimension(30, 20));
      horizontalBox.add(rigidArea_4);
      horizontalBox.add(b3);
      
      Component horizontalGlue_1 = Box.createHorizontalGlue();
      horizontalBox.add(horizontalGlue_1);
      
      Box horizontalBox_2 = Box.createHorizontalBox();
      sl_panel.putConstraint(SpringLayout.NORTH, horizontalBox, 6, SpringLayout.SOUTH, horizontalBox_2);
      sl_panel.putConstraint(SpringLayout.NORTH, horizontalBox_2, 6, SpringLayout.SOUTH, horizontalBox_1);
      sl_panel.putConstraint(SpringLayout.WEST, horizontalBox_2, 0, SpringLayout.WEST, horizontalBox_1);
      sl_panel.putConstraint(SpringLayout.EAST, horizontalBox_2, 0, SpringLayout.EAST, horizontalBox_1);
      panel.add(horizontalBox_2);
      
      sliderY1 = new JSlider();
      sliderY1.setPreferredSize(new Dimension(220, 26));
      sliderY1.setMajorTickSpacing(1);
      sliderY1.setMaximum(298);
      sliderY1.addChangeListener(new ChangeListener() {
         public void stateChanged(ChangeEvent e) {
            int value = sliderY1.getValue();
            spinner_Y1.setValue(value);            
         }
      });
      sliderY1.setBackground(SystemColor.menu);
      sliderY1.setValue(0);
      sliderY1.setForeground(Color.WHITE);
      horizontalBox_2.add(sliderY1);
      
      sliderX1 = new JSlider();
      sliderX1.setPreferredSize(new Dimension(220, 26));
      sliderX1.setMajorTickSpacing(1);
      sliderX1.setMaximum(700);
      sliderX1.setValue(0);
      sliderX1.addChangeListener(new ChangeListener() {
         public void stateChanged(ChangeEvent e) {
            int value = sliderX1.getValue();
            spinner_X1.setValue(value);
         }
      });
      
      Component rigidArea_10 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_10.setPreferredSize(new Dimension(15, 20));
      rigidArea_10.setMinimumSize(new Dimension(15, 20));
      rigidArea_10.setMaximumSize(new Dimension(15, 20));
      horizontalBox_2.add(rigidArea_10);
      
      sliderX1.setForeground(Color.WHITE);
      horizontalBox_2.add(sliderX1);
      
      Component rigidArea_11 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_11.setPreferredSize(new Dimension(15, 20));
      rigidArea_11.setMinimumSize(new Dimension(15, 20));
      rigidArea_11.setMaximumSize(new Dimension(15, 20));
      horizontalBox_2.add(rigidArea_11);
      
      sliderY2 = new JSlider();
      sliderY2.setMinorTickSpacing(1);
      sliderY2.setMajorTickSpacing(1);
      sliderY2.setMaximum(298);
      sliderY2.setValue(0);
      sliderY2.addChangeListener(new ChangeListener() {
         public void stateChanged(ChangeEvent e) {
            int value = sliderY2.getValue();
            spinner_Y2.setValue(value);
         }
      });
      sliderY2.setPreferredSize(new Dimension(220, 26));
      sliderY2.setForeground(Color.WHITE);
      horizontalBox_2.add(sliderY2);
      
      Component rigidArea_12 = Box.createRigidArea(new Dimension(20, 20));
      rigidArea_12.setPreferredSize(new Dimension(15, 20));
      rigidArea_12.setMinimumSize(new Dimension(15, 20));
      rigidArea_12.setMaximumSize(new Dimension(15, 20));
      horizontalBox_2.add(rigidArea_12);
      
      sliderX2 = new JSlider();
      sliderX2.setMinorTickSpacing(1);
      sliderX2.setMajorTickSpacing(1);
      sliderX2.setMaximum(700);
      sliderX2.setValue(0);
      sliderX2.addChangeListener(new ChangeListener() {
         public void stateChanged(ChangeEvent e) {
            int value = sliderX2.getValue();
            spinner_X2.setValue(value);
         }
      });
      sliderX2.setPreferredSize(new Dimension(220, 26));
      sliderX2.setSnapToTicks(true);
      sliderX2.setForeground(Color.WHITE);
      horizontalBox_2.add(sliderX2);
      graph =  new Graph(5,5,JC_WIDTH,JC_HEIGHT);
      getContentPane().add(graph);      
   }
}


Logga in för att visa de filer som bifogats till detta inlägg.


Upp
 Profil  
 
InläggPostat: 14.33 2019-08-25 
Användarvisningsbild

Blev medlem: 18.04 2009-08-16
Inlägg: 11056
Gjorde det lättare för mig och inhandlade en
Adafruit PT100 RTD Temperature Sensor Amplifier - MAX31865

Så nu ska jag lära mig programmera den och SPI dessutom.

Bild


Upp
 Profil  
 
InläggPostat: 22.13 2019-09-04 
Användarvisningsbild

Blev medlem: 18.04 2009-08-16
Inlägg: 11056
Har nu lyckats att mäta med MAX31865 kortet efter diverse
inställningar i Eclipse för att det skulle bli rätt med <SPI.h>
och <Adafruit_MAX31865.h>. Det går bra att ha dessa lokalt
i mappen med programkoden om man bara ser till att ändra
till "SPI.h" och "Adafruit_MAX31865.h" på rätt ställen men det behövs inte
om man talar om för Eclipse att de finns i .arduinocdt mappen.

Anslöt en trimpot som en 2-tråds RTD och kör exemplet från Adafruit.


Upp
 Profil  
 
InläggPostat: 08.29 2019-10-13 
Användarvisningsbild

Blev medlem: 18.04 2009-08-16
Inlägg: 11056
Har tagit en paus med projektet och det senaste jag gjort var att jag städade upp i koden ordentligt. När jag labbar med kod så kommer jag på nya enklare lösningar och lägger till det och rensar inte alltid bort den gamla koden, sånt som är onödigt. Sedan har jag testat en simulerad datainsamling med vridpotentiometrar för NTC och temperatur och det fungerar som tänkt.

Jag är i alla fall fast besluten att ha ett fungerande NTC-mätinstrument på labbänken framöver. Det återstår trots allt inte särskilt mycket för att det ska bli verklighet. Tänkte mig en låda med usb och anslutningsanordning för NTC brevid ett värmeelement.


Upp
 Profil  
 
Visa inlägg nyare än:  Sortera efter  
Svara på tråd  [ 49 inlägg ]  Gå till sida Föregående  1, 2, 3, 4

Alla tidsangivelser är UTC + 1 timme


Vilka är online

Användare som besöker denna kategori: Inga registrerade användare och 9 gäster


Du kan inte skapa nya trådar i denna kategori
Du kan inte svara på trådar i denna kategori
Du kan inte redigera dina inlägg i denna kategori
Du kan inte ta bort dina inlägg i denna kategori
Du kan inte bifoga filer i denna kategori

Sök efter:
Hoppa till:  
   
Drivs av phpBB® Forum Software © phpBB Group
Swedish translation by Peetra & phpBB Sweden © 2006-2010