aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Rendering/MouseHoverLogic.cs
blob: 857affcbb23913813f90b676b1f3e24cfaddd90d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)

using System;
using System.Windows;
using System.Windows.Input;
using System.Windows.Threading;

namespace Tango.Scripting.Editors.Rendering
{
	/// <summary>
	/// Encapsulates and adds MouseHover support to UIElements.
	/// </summary>
	public class MouseHoverLogic : IDisposable
	{
		UIElement target;
		
		DispatcherTimer mouseHoverTimer;
		Point mouseHoverStartPoint;
		MouseEventArgs mouseHoverLastEventArgs;
		bool mouseHovering;
		
		/// <summary>
		/// Creates a new instance and attaches itself to the <paramref name="target" /> UIElement.
		/// </summary>
		public MouseHoverLogic(UIElement target)
		{
			if (target == null)
				throw new ArgumentNullException("target");
			this.target = target;
			this.target.MouseLeave += MouseHoverLogicMouseLeave;
			this.target.MouseMove += MouseHoverLogicMouseMove;
			this.target.MouseEnter += MouseHoverLogicMouseEnter;
		}
		
		void MouseHoverLogicMouseMove(object sender, MouseEventArgs e)
		{
			Vector mouseMovement = mouseHoverStartPoint - e.GetPosition(this.target);
			if (Math.Abs(mouseMovement.X) > SystemParameters.MouseHoverWidth
			    || Math.Abs(mouseMovement.Y) > SystemParameters.MouseHoverHeight)
			{
				StartHovering(e);
			}
			// do not set e.Handled - allow others to also handle MouseMove
		}
		
		void MouseHoverLogicMouseEnter(object sender, MouseEventArgs e)
		{
			StartHovering(e);
			// do not set e.Handled - allow others to also handle MouseEnter
		}
		
		void StartHovering(MouseEventArgs e)
		{
			StopHovering();
			mouseHoverStartPoint = e.GetPosition(this.target);
			mouseHoverLastEventArgs = e;
			mouseHoverTimer = new DispatcherTimer(SystemParameters.MouseHoverTime, DispatcherPriority.Background, OnMouseHoverTimerElapsed, this.target.Dispatcher);
			mouseHoverTimer.Start();
		}
		
		void MouseHoverLogicMouseLeave(object sender, MouseEventArgs e)
		{
			StopHovering();
			// do not set e.Handled - allow others to also handle MouseLeave
		}
		
		void StopHovering()
		{
			if (mouseHoverTimer != null) {
				mouseHoverTimer.Stop();
				mouseHoverTimer = null;
			}
			if (mouseHovering) {
				mouseHovering = false;
				OnMouseHoverStopped(mouseHoverLastEventArgs);
			}
		}
		
		void OnMouseHoverTimerElapsed(object sender, EventArgs e)
		{
			mouseHoverTimer.Stop();
			mouseHoverTimer = null;
			
			mouseHovering = true;
			OnMouseHover(mouseHoverLastEventArgs);
		}
		
		/// <summary>
		/// Occurs when the mouse starts hovering over a certain location.
		/// </summary>
		public event EventHandler<MouseEventArgs> MouseHover;
		
		/// <summary>
		/// Raises the <see cref="MouseHover"/> event.
		/// </summary>
		protected virtual void OnMouseHover(MouseEventArgs e)
		{
			if (MouseHover != null) {
				MouseHover(this, e);
			}
		}
		
		/// <summary>
		/// Occurs when the mouse stops hovering over a certain location.
		/// </summary>
		public event EventHandler<MouseEventArgs> MouseHoverStopped;
		
		/// <summary>
		/// Raises the <see cref="MouseHoverStopped"/> event.
		/// </summary>
		protected virtual void OnMouseHoverStopped(MouseEventArgs e)
		{
			if (MouseHoverStopped != null) {
				MouseHoverStopped(this, e);
			}
		}
		
		bool disposed;
		
		/// <summary>
		/// Removes the MouseHover support from the target UIElement.
		/// </summary>
		public void Dispose()
		{
			if (!disposed) {
				this.target.MouseLeave -= MouseHoverLogicMouseLeave;
				this.target.MouseMove -= MouseHoverLogicMouseMove;
				this.target.MouseEnter -= MouseHoverLogicMouseEnter;
			}
			disposed = true;
		}
	}
}
ADC channel control should be used for each // kind of data item. Basically it maps how the ADC channels are connected // on the board. This is a hardware pinmap configuration. // Physical ADC connected channels in the TIVA //***************************************************************************** #define CHAN_AIR_PRESSURE_1 ADC_CTL_CH0 #define CHAN_AIR_PRESSURE_2 ADC_CTL_CH1 #define CHAN_DISPENSE_PRESSURE_1 ADC_CTL_CH2 #define CHAN_DISPENSE_PRESSURE_2 ADC_CTL_CH3 #define CHAN_DISPENSE_PRESSURE_3 ADC_CTL_CH4 #define CHAN_DISPENSE_PRESSURE_4 ADC_CTL_CH5 #define CHAN_DISPENSE_PRESSURE_5 ADC_CTL_CH6 #define CHAN_DISPENSE_PRESSURE_6 ADC_CTL_CH7 #define CHAN_DISPENSE_PRESSURE_7 ADC_CTL_CH8 #define CHAN_DISPENSE_PRESSURE_8 ADC_CTL_CH9 #define CHAN_VOCSENS ADC_CTL_CH10 #define CHAN_SPARE1 ADC_CTL_CH11 #define CHAN_SPARE2 ADC_CTL_CH12 #define CHAN_LEFT_DANCER_1 ADC_CTL_CH13 #define CHAN_LEFT_DANCER_2 ADC_CTL_CH14 #define CHAN_RIGHT_DANCER ADC_CTL_CH15 #define CHAN_DRYER_CURRENT_2 ADC_CTL_CH16 //Dryer Heater 2 #define CHAN_DRYER_CURRENT_1 ADC_CTL_CH17 //Dryer Heater 1 #define CHAN_DRYER_CURRENT_3 ADC_CTL_CH18 #define CHAN_3V3_FPGA ADC_CTL_CH19 /* Connected with pull down to reg GND ADC_CTL_CH20 Connected with pull down to reg GND ADC_CTL_CH21 config as digital input from FPGA 3 ADC_CTL_CH22 config as Digital input from FPGA 3 ADC_CTL_CH23 */ //***************************************************************************** // // The following maps the order that items are acquired and stored by the // ADC sequencers. Note that 16 samples are specified, using 2 of the // 8 sample sequencers. The current is sampled multiple times deliberately // because that value tends to bounce around. It is sampled multiple // times and will be averaged. // //***************************************************************************** uint32_t g_pui32ADCSeq[ADC_MAX_ADC_DEVICES] = { CHAN_AIR_PRESSURE_1, //0 CHAN_AIR_PRESSURE_2, //1 CHAN_DISPENSE_PRESSURE_1, //2 J0252 ,PIN 21 - AN_IDS_PRESSENS_1, PIN 9 - GND CHAN_DISPENSE_PRESSURE_2, //3 J0142 ,PIN 21 - AN_IDS_PRESSENS_2, PIN 9 - GND CHAN_DISPENSE_PRESSURE_3, //4 J0042 ,PIN 21 - AN_IDS_PRESSENS_3, PIN 9 - GND CHAN_DISPENSE_PRESSURE_4, //5 J0152 ,PIN 21 - AN_IDS_PRESSENS_4, PIN 9 - GND CHAN_DISPENSE_PRESSURE_5, //6 J0162 ,PIN 21 - AN_IDS_PRESSENS_5, PIN 9 - GND CHAN_DISPENSE_PRESSURE_6, //7 J0262 ,PIN 21 - AN_IDS_PRESSENS_6, PIN 9 - GND CHAN_DISPENSE_PRESSURE_7, //8 J0062 ,PIN 21 - AN_IDS_PRESSENS_7, PIN 9 - GND CHAN_DISPENSE_PRESSURE_8, //9 J0052 ,PIN 21 - AN_IDS_PRESSENS_8, PIN 9 - GND CHAN_VOCSENS, //10 J0072 ,PIN 21 - AN_VOCSENS, PIN 9 - GND CHAN_SPARE1, //11 CHAN_SPARE2, //12 CHAN_LEFT_DANCER_1, //13 J0002 ,PIN 21 - AN5V_LDANCER1, PIN 9 - GND CHAN_LEFT_DANCER_2, //14 J0002 ,PIN 22 - AN5V_LDANCER1, PIN 10 - GND CHAN_RIGHT_DANCER, //15 J0102 ,PIN 21 - AN5V_RDANCER, PIN 9 - GND CHAN_DRYER_CURRENT_1, //16 J1292 ,PIN 7 - AN_DRYER_CURSEN_1p, PIN 19 - AN_DRYER_CURSEN_1n CHAN_DRYER_CURRENT_2, //17 J1292 ,PIN 8 - AN_DRYER_CURSEN_1p, PIN 20 - AN_DRYER_CURSEN_1n CHAN_DRYER_CURRENT_3, //18 J1292 ,PIN 9 - AN_DRYER_CURSEN_1p, PIN 21 - AN_DRYER_CURSEN_1n CHAN_3V3_FPGA, //19 }; //#define NUM_ADC_CHANNELS (sizeof(g_pui32ADCSeq) / \ sizeof(g_pui32ADCSeq[0])) int DispenserIdToPressureSensorId[MAX_DISPENSERS] = {ADC_DISPENSE_PRESSURE_1, ADC_DISPENSE_PRESSURE_2 , ADC_DISPENSE_PRESSURE_3 , ADC_DISPENSE_PRESSURE_4 , ADC_DISPENSE_PRESSURE_5 , ADC_DISPENSE_PRESSURE_6 , ADC_DISPENSE_PRESSURE_7 , ADC_DISPENSE_PRESSURE_8 }; //const uint8_t Num_ADC_Channels = ( sizeof(g_pui32ADCSeq) / sizeof(g_pui32ADCSeq[0]) ); //#define SAMPLE_ARRAY_SIZE (NUM_ADC_CHANNELS + I2C_NUM_OF_CHANNELS) //#define SAMPLE_ARRAY_SIZE NUM_ADC_CHANNELS static bool isInitialized = false; static bool adcCollectActive = false; static int bufferFlipFlop = 0; //***************************************************************************** // // Global _storage for most recent sampled Sensor Data // //***************************************************************************** // // A buffer to hold one set of ADC data that is acquired per sample time. // //***************************************************************************** static uint32_t g_pui32ADCData[DOUBLE_BUFFER][ADC_MAX_ADC_DEVICES]; //***************************************************************************** //configured in the cfg file and thats why should be defined as extern //***************************************************************************** extern Semaphore_Handle adcResultSem; static ProcessCallback processCallBack; //***************************************************************************** // ADCClockHandle: clock event handler - initiates trigger for the adc sampaling //***************************************************************************** // This function starts an ADC Conversion. //static void ADCClockHandle(UArg arg0) uint32_t ADC_TriggerCollection(void) // (called by MillisecLoop) { // // Kick off the next ADC acquisition. When these are done they will // cause an ADC interrupt. // if (adcCollectActive == true) { MAP_ADCProcessorTrigger(ADC1_BASE, 0); MAP_ADCProcessorTrigger(ADC0_BASE, 0); MAP_ADCProcessorTrigger(ADC0_BASE, 1); } return 0; } //***************************************************************************** // // ADC Data get for a single data read // //***************************************************************************** uint32_t ADC_GetReading(ADC_TYPE DataItemId) // 0 - 19 // ADC Data get for a single data read { int bufnotinuse; assert (DataItemId<ADC_MAX_ADC_DEVICES); if (bufferFlipFlop == 0) bufnotinuse = 1; else bufnotinuse = 0; return (g_pui32ADCData[bufnotinuse][DataItemId]); } //***************************************************************************** // // This is the handler for the ADC interrupt. Even though more than one // sequencer is used, they are configured so that this one runs last. // Therefor when this ADC sequencer interrupt occurs, we know all of the ADC // data has been acquired. // //***************************************************************************** void ADC0SS0Handler(void) { // // Clear the interrupts for all ADC sequencers that are used. // MAP_ADCIntClear(ADC0_BASE, 0); MAP_ADCIntClear(ADC1_BASE, 0); MAP_ADCIntClear(ADC0_BASE, 1); if (bufferFlipFlop == 0) bufferFlipFlop = 1; else bufferFlipFlop = 0; // // Retrieve the data from all ADC sequencers // MAP_ADCSequenceDataGet(ADC0_BASE, 0, &g_pui32ADCData[bufferFlipFlop][0]); //offset in the array calculated as sampling of 16 channels each one of 16 bits MAP_ADCSequenceDataGet(ADC1_BASE, 0, &g_pui32ADCData[bufferFlipFlop][8]); MAP_ADCSequenceDataGet(ADC0_BASE, 1, &g_pui32ADCData[bufferFlipFlop][16]); // // Release adc result semaphore // //the ADC Process task is mot currently active. the results will be copied to a second buffer and supplied upon request //Semaphore_post(adcResultSem); } //***************************************************************************** // //***************************************************************************** Void ADCProcessTask(UArg arg0, UArg arg1) { while(1) { // // Wait until new ADC data is available // Semaphore_pend(adcResultSem, BIOS_WAIT_FOREVER); // // Process the ADC data // if (processCallBack != NULL) { processCallBack(g_pui32ADCData[bufferFlipFlop]); } } } void ADCAcquireInit(void) // (called by MillisecInit) { uint32_t ui32Chan, ui32Base, ui32Seq; #ifndef EVALUATION_BOARD //Avaraging 8 //TODO //MAP_ADCHardwareOversampleConfigure(ADC0_BASE, 8); //MAP_ADCHardwareOversampleConfigure(ADC1_BASE, 8); // // Initialize both ADC peripherals using sequencer 0 and processor trigger. // MAP_ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0); MAP_ADCSequenceConfigure(ADC1_BASE, 0, ADC_TRIGGER_PROCESSOR, 0); MAP_ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 1); //sequencer 1 ADCSequenceDisable(ADC0_BASE, 1); // // Enter loop to configure all of the ADC sequencer steps needed to // acquire the data for the data logger. Multiple ADC and sequencers // will be used in order to acquire all the channels. // for(ui32Chan = 0; ui32Chan < ADC_MAX_ADC_DEVICES; ui32Chan++) { // // If this is the first ADC then set the base for ADC0 // if(ui32Chan < 8) { ui32Base = ADC0_BASE; ui32Seq = 0; } else if(ui32Chan < 16) { // // Second ADC, set the base for ADC1 // ui32Base = ADC1_BASE; ui32Seq = 0; } else { ui32Base = ADC0_BASE; ui32Seq = 1; } // // Get the channel control for each channel. Test to see if it is the // last channel for the sequencer, and if so then also set the // interrupt and "end" flags. // uint32_t ui32ChCtl = g_pui32ADCSeq[ui32Chan]; //TODO define all the numbers under #define and not here if((ui32Chan == 7) || (ui32Chan == 15) || (ui32Chan == (ADC_MAX_ADC_DEVICES - 1))) { ui32ChCtl |= ADC_CTL_IE | ADC_CTL_END; } // // Configure the sequence step // MAP_ADCSequenceStepConfigure(ui32Base, ui32Seq, ui32Chan % 8, ui32ChCtl); } ADCSequenceEnable(ADC0_BASE, 1); ADCReferenceSet(ADC0_BASE, ADC_REF_EXT_3V); ADCReferenceSet(ADC1_BASE, ADC_REF_EXT_3V); VOCAlarmsInit(); if (!isInitialized) { // Create a periodic Clock Instance with _period - triggers the ADC sampling isInitialized = true; //InitI2C(); } #endif } //***************************************************************************** // // This function is called to start an acquisition running. It determines // which channels are to be logged, enables the ADC/I2C sequencers. // This will start the acquisition running. // //***************************************************************************** void ADCAcquireStart(ProcessCallback _callback, uint32_t _period) // (called by MillisecStart) { #ifndef EVALUATION_BOARD // // Enable the ADC sequencers // MAP_ADCSequenceEnable(ADC0_BASE, 0); MAP_ADCSequenceEnable(ADC1_BASE, 0); MAP_ADCSequenceEnable(ADC0_BASE, 1); // // Flush the ADC sequencers to be sure there is no lingering/ trush data. // MAP_ADCSequenceDataGet(ADC0_BASE, 0, g_pui32ADCData[0]); MAP_ADCSequenceDataGet(ADC1_BASE, 0, g_pui32ADCData[0]); MAP_ADCSequenceDataGet(ADC1_BASE, 1, g_pui32ADCData[0]); // // Enable ADC interrupts // MAP_ADCIntClear(ADC0_BASE, 0); MAP_ADCIntClear(ADC1_BASE, 0); MAP_ADCIntEnable(ADC0_BASE, 0); MAP_ADCIntEnable(ADC0_BASE, 1); ROM_IntEnable(INT_ADC0SS0); // Store process processCallBack = _callback; // Start a periodic Clock Instance with _period - triggers the ADC sampling adcCollectActive = true; // // Logging data should now start running // #endif } //***************************************************************************** // // This function is called to stop an acquisition running. It disables the // ADC sequencers. // //***************************************************************************** void ADCAcquireStop(void) { //Stop trigger adc sampling adcCollectActive = false; // // Disable ADC interrupts // MAP_IntDisable(INT_ADC0SS0); MAP_IntDisable(INT_ADC1SS0); // // Disable ADC sequencers // MAP_ADCSequenceDisable(ADC0_BASE, 0); MAP_ADCSequenceDisable(ADC1_BASE, 0); MAP_ADCSequenceDisable(ADC0_BASE, 1); } double VPressure_0 = 0; double A_offset =-2.429, B_slope_coefficient = 0.267;//A - offset, B - slope coefficient double Calculate_Pitot_Pressure(bool flow ) // WHS - AN_AIRPRESS_1 { //MPXV7002 (NXP) uint32_t VsampleInBits; double Pressure = 0.0, temp, /*PKpa,PBar,*/VADC = 0.0 ,VSensor/*,PMicroBar*/; VsampleInBits = ADC_GetReading(ADC_AIR_PRESSURE_1); //---- VBits -> VADC ---- //ADC 12 bit -> 4096 -> 2.5V temp = VsampleInBits*2.5; VADC = temp / 4096; //---- VADC -> VSensor --- //VADC = 1.96 - 10k( VSensor - 1.96) / 46.4k (from the electrical scheme) // VSensor = 0 V -> VADC = 2.3824 V // VSensor = 10 V -> VADC = 0.2272 V VSensor = (1.96- VADC) * 4.64 + 1.96; if(flow == false) { VPressure_0 = VSensor; return VPressure_0; } else { Pressure = A_offset + B_slope_coefficient * (sqrt(VSensor - VPressure_0)); /* PKpa = 5 * VSensor; // ---- P[Kpa] -> BAR ---- PBar = PKpa / 100.0; PMicroBar = PBar/1000; Pressure = PMicroBar;*/ return Pressure; } } uint32_t Read_Dryer_Heaters_Current(HEATERS_CURRENT Heater_ID) // { /* * On Dryer have two heaters , 4*220w and 2*220w that work on 220Vac. Current transformer convert (thru resistor ) the Current of load to Voltage then convert from RMS to DC and connect to A2D pin of Tiva. A2D is 12 bits and his reference is 3.3V (VDDA) or 3V(VREFA+) (depend on s/w). I=A2D bits *K *VREF *N /(4096*R) Where : K= K factor of transformer (less than 1 ) VREF 3 or 3.3v depended of s/w N turns ratio (800 in our case ) Heater_No. Heater_SSR Resistor Power Current AIN# Heater_1 4 SSR_1 50 ohm 880W 8A 17 Heater_2 2 SSR_2 100 ohm 440W 4A 16 * */ uint32_t Status = OK; float temp = 0; float Vref = 3; // External 3V reference using - ADC_REF_EXT_3V float K = 95; //0.95; //See graph in data sheet of CTL-6 float N = 800; //See data sheet of CTL-6 float R; // if (Heaters_Current_Read_Enable[Heater_ID] == false) return ERROR; // Heaters_Current[Heater_ID] switch(Heater_ID) { case HEATER_DRYER_CURRENT_1: temp = ADC_GetReading(ADC_DRYER_CURRENT_1);//ADC_CTL_CH17 R = 50;//50 Ohm //Expected 8A break; case HEATER_DRYER_CURRENT_2: temp = ADC_GetReading(ADC_DRYER_CURRENT_2);//ADC_CTL_CH16 R = 100;//100 Ohm //Expected 4A break; // case DRYER_CURRENT_3: // temp = ADC_GetReading(ADC_DRYER_CURRENT_3);//Not in use // break; default: return ERROR; //break; } Heaters_Current_Bits[Heater_ID] = temp; Heaters_Current[Heater_ID] = (double)((temp * 100 / K * Vref * N) / (4096 * R));// [Amper] // ReportWithPackageFilter(HeatersFilter,"------------Heaters_Current-----------------", __FILE__,__LINE__,Heater_ID, RpMessage, Heaters_Current[Heater_ID]*10000, 0); return Status; } PowerControlFlag Power_Control_Flag; uint8_t Input_Voltage; void CheckAcInputVoltage() { //TODO Change to external Parameters uint8_t High_Voltage_Limit = 237;//for 264V AC - 10% uint8_t Low_Voltage_Limit = 204;//for 185 VAC + 10% //-------------------------------------------------- uint8_t Rt_Heaters_Zone1 = 60; //240||240||240||240 Ohm //uint8_t Rt_Heaters_Zone2 = 120;//240||240 Ohm Read_Heaters_Current(HEATER_DRYER_CURRENT_1); Input_Voltage = Heaters_Current[HEATER_DRYER_CURRENT_1] * Rt_Heaters_Zone1; if( (Input_Voltage) > High_Voltage_Limit ) { Power_Control_Flag = High_Voltage; } else if( (Input_Voltage) < Low_Voltage_Limit ) { Power_Control_Flag = Low_Voltage_Limit; } else { Power_Control_Flag = Normal_Voltage; } }