path: root/tags/host/0.8.1/src/org/reprap/devices/NullExtruder.java

/**
 * 
 */
package org.reprap.devices;

import java.io.IOException;
import org.reprap.Device;
import org.reprap.Extruder;
import org.reprap.Preferences;
import javax.media.j3d.Appearance;
import javax.vecmath.Color3f;
import javax.media.j3d.Material;

/**
 * @author Adrian
 *
 */
public class NullExtruder implements Extruder{
	
	/**
	 * Offset of 0 degrees centigrade from absolute zero
	 */
	private static final double absZero = 273.15;
	
	/**
	 * The temperature to maintain
	 */ 
	private double requestedTemperature = 0;
	
	/**
	 * The temperature most recently read from the device 
	 */
	private double currentTemperature = 0;
	
	/**
	 * 
	 */
	private boolean currentMaterialOutSensor = false;
	
	/**
	 * Indicates when polled values are first ready 
	 */
	private boolean sensorsInitialised = false;
	
	/**
	 * 
	 */
	private Thread pollThread = null;
	
	/**
	 * 
	 */
	private boolean pollThreadExiting = false;

	/**
	 * 
	 */
	private int vRefFactor = 7;
	
	/**
	 * 
	 */
	private int tempScaler = 4;
	
	/**
	 * Thermistor beta
	 */
	private double beta; 
	
	/**
	 * Thermistor resistance at 0C
	 */
	private double rz;
	
	/**
	 * Thermistor timing capacitor in farads
	 */
	private double cap; 
	
	/**
	 * Heater power gradient
	 */	
	private double hm;
	
	/**
	 * Heater power intercept
	 * TODO hb should probably be ambient temperature measured at this point
	 */
	private double hb;
	
	/**
	 * Maximum motor speed (0-255)
	 */
	private int maxExtruderSpeed;
	
	/**
	 * The actual extrusion speed
	 */
	private int extrusionSpeed;
	
	/**
	 * The extrusion temperature
	 */
	private double extrusionTemp;
	
	/**
	 * The extrusion width in XY
	 */
	private double extrusionSize;
	
	/**
	 * The extrusion height in Z
	 * Should this be a machine-wide constant? - AB
	 */
	private double extrusionHeight;
	
	
	/**
	 * The step between infill tracks
	 */
	private double extrusionInfillWidth;
	
	/**
	 * The number of mm to stop extruding before the end of a track
	 */
	private double extrusionOverRun;
	
	/**
	 * The number of ms to wait before starting a track
	 */
	private int extrusionDelay;
	
	/**
	 * The number of s to cool between layers
	 */
	private int coolingPeriod; 
	
	/**
	 * The speed of movement in XY when depositing
	 */
	private int xySpeed;
	
	/**
	 * Zero torque speed
	 */
	private int t0;      
	
	/**
	 * Infill speed [0,1]*maxSpeed
	 */
	private double iSpeed;
	
	/**
	 * Outline speed [0,1]*maxSpeed
	 */
	private double oSpeed;	
	
	/**
	 * Length (mm) to speed up round corners
	 */
	private double asLength; 
	
	/**
	 * Factor by which to speed up round corners
	 */
	private double asFactor;
	
	/**
	 * The name of this extruder's material
	 */
	private String materialType;
	
	/**
	 * Where to put the nozzle
	 */
	private double offsetX, offsetY, offsetZ;
	
	/**
	 * 
	 */
	private long lastTemperatureUpdate = 0;
	
	
	
	/** 
	 * Flag indicating if initialisation succeeded.  Usually this
	 * indicates if the extruder is present in the network.
	 */
	private boolean isCommsAvailable = false;

	
	/**
	 *  The colour black
	 */	
	protected static final Color3f black = new Color3f(0, 0, 0);
	
	/**
	 *  The colour of the material to use in the simulation windows 
	 */	
	private Appearance materialColour;
	

	/**
	 * @param prefs
	 * @param extruderId
	 */
	public NullExtruder(Preferences prefs, int extruderId) {

		String prefName = "Extruder" + extruderId + "_";
		
		beta = prefs.loadDouble(prefName + "Beta(K)");
		rz = prefs.loadDouble(prefName + "Rz(ohms)");
		cap = prefs.loadDouble(prefName + "Capacitor(F)");
		hm = prefs.loadDouble(prefName + "hm(C/pwr)");
		hb = prefs.loadDouble(prefName + "hb(C)");
		maxExtruderSpeed = prefs.loadInt(prefName + "MaxSpeed(0..255)");
		extrusionSpeed = prefs.loadInt(prefName + "ExtrusionSpeed(0..255)");
		extrusionTemp = prefs.loadDouble(prefName + "ExtrusionTemp(C)");
		extrusionSize = prefs.loadDouble(prefName + "ExtrusionSize(mm)");
		extrusionHeight = prefs.loadDouble(prefName + "ExtrusionHeight(mm)");
		extrusionInfillWidth = prefs.loadDouble(prefName + "ExtrusionInfillWidth(mm)");
		extrusionOverRun = prefs.loadDouble(prefName + "ExtrusionOverRun(mm)");
		extrusionDelay = prefs.loadInt(prefName + "ExtrusionDelay(ms)");
		coolingPeriod = prefs.loadInt(prefName + "CoolingPeriod(s)");
		xySpeed = prefs.loadInt(prefName + "XYSpeed(0..255)");
		t0 = prefs.loadInt(prefName + "t0(0..255)");
		iSpeed = prefs.loadDouble(prefName + "InfillSpeed(0..1)");
		oSpeed = prefs.loadDouble(prefName + "OutlineSpeed(0..1)");
		asLength = prefs.loadDouble(prefName + "AngleSpeedLength(mm)");
		asFactor = prefs.loadDouble(prefName + "AngleSpeedFactor(0..1)");
		materialType = prefs.loadString(prefName + "MaterialType(name)");
		offsetX = prefs.loadDouble(prefName + "OffsetX(mm)");
		offsetY = prefs.loadDouble(prefName + "OffsetY(mm)");
		offsetZ = prefs.loadDouble(prefName + "OffsetZ(mm)");

		materialColour = getAppearanceFromNumber(extruderId);		
			
		isCommsAvailable = true;
	
	}

	/* (non-Javadoc)
	 * @see org.reprap.Extruder#dispose()
	 */
	public void dispose() {
		if (pollThread != null) {
			pollThreadExiting = true;
			pollThread.interrupt();
		}
	}

	/**
	 * Start the extruder motor at a given speed.  This ranges from 0
	 * to 255 but is scaled by maxSpeed and t0, so that 255 corresponds to the
	 * highest permitted speed.  It is also scaled so that 0 would correspond
	 * with the lowest extrusion speed.
	 * @param speed The speed to drive the motor at (0-255)
	 * @throws IOException
	 */
	public void setExtrusion(int speed) throws IOException {
		setExtrusion(speed, false);
	}
	
	/**
	 * Start the extruder motor at a given speed.  This ranges from 0
	 * to 255 but is scaled by maxSpeed and t0, so that 255 corresponds to the
	 * highest permitted speed.  It is also scaled so that 0 would correspond
	 * with the lowest extrusion speed.
	 * @param speed The speed to drive the motor at (0-255)
	 * @param reverse If set, run extruder in reverse
	 * @throws IOException
	 */
	public void setExtrusion(int speed, boolean reverse) throws IOException {
		// Assumption: Between t0 and maxSpeed, the speed is fairly linear

	}

	/* (non-Javadoc)
	 * @see org.reprap.Extruder#heatOn()
	 */
	public void heatOn() throws Exception 
	{
		
	}
	
	/**
	 * Set extruder temperature
	 * @param temperature
	 * @throws Exception
	 */
	public void setTemperature(double temperature) throws Exception {
		
	}
	
	/**
	 * Set a heat output power.  For normal production use you would
	 * normally call setTemperature, however this method may be useful
	 * for lower temperature profiling, etc.
	 * @param heat Heater power (0-255)
	 * @param maxTemp Cutoff temperature in celcius
	 * @throws IOException
	 */
	public void setHeater(int heat, double maxTemp) throws IOException {

	}
	

	/**
	 * Check if the extruder is out of feedstock
	 * @return true if there is no material remaining
	 */
	public boolean isEmpty() {
		return currentMaterialOutSensor;
	}
	


	/* (non-Javadoc)
	 * @see org.reprap.Extruder#getTemperatureTarget()
	 */
	public double getTemperatureTarget() {
		return requestedTemperature;
	}

	/* (non-Javadoc)
	 * @see org.reprap.Extruder#getDefaultTemperature()
	 */
	public double getDefaultTemperature() {
		return extrusionTemp;
	}	

	
	/* (non-Javadoc)
	 * @see org.reprap.Extruder#getTemperature()
	 */
	public double getTemperature() {
		return currentTemperature;
	}

	/**
	 * The the outline speed and the infill speed [0,1]
	 */
	public double getInfillSpeed()
	{
		return iSpeed;
	}
	public double getOutlineSpeed()
	{
		return oSpeed;
	}
	
	/**
	 * The length in mm to speed up when going round corners
	 */
	public double getAngleSpeedUpLength()
	{
		return asLength;
	}
	
	/**
	 * The factor by which to speed up when going round a corner.
	 * The formula is speed = baseSpeed*[1 - 0.5*(1 + ca)*getAngleSpeedFactor()]
	 * where ca is the cos of the angle between the lines.  So it goes fastest when
	 * the line doubles back on itself (returning 1), and slowest when it 
	 * continues straight (returning 1 - getAngleSpeedFactor()).
	 */	
	public double getAngleSpeedFactor()
	{
		return asFactor;
	}	
	
	
	/* (non-Javadoc)
	 * @see org.reprap.Extruder#setCooler(boolean)
	 */
	public void setCooler(boolean f) throws IOException {

	}

	/* (non-Javadoc)
	 * @see org.reprap.Extruder#isAvailable()
	 */
	public boolean isAvailable() {
		return isCommsAvailable;
	}

    /* (non-Javadoc)
     * @see org.reprap.Extruder#getXYSpeed()
     */
    public int getXYSpeed()
    {
    	return xySpeed;
    }
    
    /* (non-Javadoc)
     * @see org.reprap.Extruder#getExtruderSpeed()
     */
    public int getExtruderSpeed()
    {
    	return extrusionSpeed;
    } 
    
    /* (non-Javadoc)
     * @see org.reprap.Extruder#getExtrusionSize()
     */
    public double getExtrusionSize()
    {
    	return extrusionSize;
    } 
    
    /* (non-Javadoc)
     * @see org.reprap.Extruder#getExtrusionHeight()
     */
    public double getExtrusionHeight()
    {
    	return extrusionHeight;
    } 
    
    /* (non-Javadoc)
     * @see org.reprap.Extruder#getExtrusionInfillWidth()
     */
    public double getExtrusionInfillWidth()
    {
    	return extrusionInfillWidth;
    } 
    
    /* (non-Javadoc)
     * @see org.reprap.Extruder#getExtrusionOverRun()
     */
    public double getExtrusionOverRun()
    {
    	return extrusionOverRun;
    } 
    
    /* (non-Javadoc)
     * @see org.reprap.Extruder#getExtrusionDelay()
     */
    public long getExtrusionDelay()
    {
    	return extrusionDelay;
    } 
    
    /* (non-Javadoc)
     * @see org.reprap.Extruder#getCoolingPeriod()
     */
    public int getCoolingPeriod()
    {
    	return coolingPeriod;
    } 
    
    /* (non-Javadoc)
     * @see org.reprap.Extruder#getOffsetX()
     */
    public double getOffsetX()
    {
    	return offsetX;
    }    
    
    /* (non-Javadoc)
     * @see org.reprap.Extruder#getOffsetY()
     */
    public double getOffsetY()
    {
    	return offsetY;
    }
    
    /* (non-Javadoc)
     * @see org.reprap.Extruder#getOffsetZ()
     */
    public double getOffsetZ()
    {
    	return offsetZ;
    }
    
    /* (non-Javadoc)
     * @see org.reprap.Extruder#getColour()
     */     
    public Appearance getAppearance()
    {
    	return materialColour;
    }  
    
    public static int getNumberFromMaterial(String material)
    {
    	String[] names;
		try
		{
			names = Preferences.allMaterials();
			for(int i = 0; i < names.length; i++)
			{
				if(names[i].equals(material))
					return i;
			}

		} catch (Exception ex)
		{
			System.err.println(ex.toString());
		}
		return -1;
    }
    
    public static Appearance getAppearanceFromNumber(int n)
    {
    	String prefName = "Extruder" + n + "_";
    	Color3f col = null;
		try
		{
			col = new Color3f((float)Preferences.loadGlobalDouble(prefName + "ColourR(0..1)"), 
				(float)Preferences.loadGlobalDouble(prefName + "ColourG(0..1)"), 
				(float)Preferences.loadGlobalDouble(prefName + "ColourB(0..1)"));
		} catch (Exception ex)
		{
			System.err.println(ex.toString());
		}
		Appearance a = new Appearance();
		a.setMaterial(new Material(col, black, col, black, 101f));
		return a;
    }
}