Subversion Repositories group.electronics

Rev

Rev 175 | Rev 181 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
161 pfowler 1 
using System;
2 
using System.Collections.Generic;
3 
using System.Linq;
4 
using System.Text;
5 
using System.Threading.Tasks;
6 
 
7 
namespace nitdcscore {
171 pfowler 8 
 
9 
    public class jsaxis {
10 
        public UInt16 prev { get; set; }        // The previous ADC value
11 
        public UInt16 value { get; set; }       // The current ADC value
12 
        public UInt16 thres { get; set; }       // Threshold to report a new position
13 
        public UInt16 max { get; set; }              // The maximum value we've seen
14 
        public UInt16 mapsize { get; set; }     // The mapping maximum
15 
 
16 
        public jsaxis() {
17 
 
18 
        }
19 
 
20 
        public bool getPosition(ref UInt16 position) {
21 
            if (this.value > this.max)
22 
                this.max = this.value;
23 
 
24 
            UInt16 lowerval = 0;
25 
            if (this.prev >= this.thres)
26 
                lowerval = (UInt16)(this.prev - this.thres);
27 
 
28 
            ushort upperval = this.max;
29 
            if (this.prev <= upperval - this.thres)
30 
                upperval = (ushort)(this.prev + this.thres);
31 
 
32 
            //Console.WriteLine("JS " + ":" + this.prev + "," + this.value + "," + this.max + "," + lowerval + "," + upperval);
33 
 
34 
            if ((this.value < lowerval) || (this.value > upperval)) {
35 
                // Cover our min/max ranges within threshold
36 
                if (this.value < this.thres)
37 
                    this.value = 0;
38 
                if (this.value > this.max - this.thres)
39 
                    this.value = this.max;
40 
 
41 
 
42 
                this.prev = this.value;
43 
 
44 
                position = Globals.map_uint16(this.value, 0, this.max, 0, this.mapsize);
45 
 
46 
                return true;
47 
            }
48 
 
49 
            return false;
50 
        }
51 
    }
52 
 
53 
    public class jsdata {
54 
        public bool changed { get; set; }
55 
        public UInt64 buttons { get; set; }
56 
        public UInt64 prev { get; set; }
57 
 
58 
        public jsaxis[] axis = new jsaxis[6];
59 
 
60 
        public jsdata() {
61 
            changed = false;
62 
            prev = buttons = 0;
63 
 
64 
            for (int i = 0; i < 6; i++) {
65 
                axis[i] = new jsaxis();
66 
                axis[i].thres = Globals.ADC_THRESHOLD;
67 
                axis[i].max = Globals.ADC_DEFMAX;
68 
                axis[i].prev = axis[i].value = 0;
69 
                axis[i].mapsize = 0xffff;
70 
            }
71 
        }
72 
    }
73 
 
74 
    public class Led {
172 pfowler 75 
        public int bank { get; set; }
76 
        public int pin { get; set; }
77 
        public UInt16 address { get; set; }
78 
        public UInt16 mask { get; set; }
79 
        public int shift { get; set; }
171 pfowler 80 
        public uint value { get; set; }
175 pfowler 81 
        private UInt16 prevdata;
171 pfowler 82 
 
172 pfowler 83 
        public Led(int bank, int pin, UInt16 address, UInt16 mask, int shift) {
171 pfowler 84 
            this.pin = pin;
85 
            this.address = address;
86 
            this.mask = mask;
87 
            this.shift = shift;
88 
            this.value = 0;
89 
 
172 pfowler 90 
            UInt16 data;
91 
            if (!Globals.BiosOutput.TryGetValue(this.address, out data)) {
92 
                Globals.BiosOutput.Add(this.address, 0x0000);
93 
            }
94 
 
171 pfowler 95 
        }
96 
 
172 pfowler 97 
        public bool Tick(ref byte shadow) {
173 pfowler 98 
 
172 pfowler 99 
            UInt16 data;
100 
            byte tmpshadow = shadow;
101 
            if (Globals.BiosOutput.TryGetValue(this.address, out data)) {
175 pfowler 102 
                // Only continue if the data parm has changed
103 
                if (data == this.prevdata)
104 
                    return false;
105 
                this.prevdata = data;
173 pfowler 106 
 
172 pfowler 107 
                this.value = (UInt16)((data & mask) >> shift);
171 pfowler 108 
 
172 pfowler 109 
                if (this.value == 1)
173 pfowler 110 
                    Globals.setBit(ref shadow, this.pin);
172 pfowler 111 
                else
173 pfowler 112 
                    Globals.clearBit(ref shadow, this.pin);
171 pfowler 113 
            }
114 
 
175 pfowler 115 
            // Only update the led if the led value has changed
172 pfowler 116 
            if (tmpshadow == shadow)
117 
                return false;
118 
 
175 pfowler 119 
            // Return true to signal the panel to update the led
171 pfowler 120 
            return true;
121 
        }
122 
 
123 
    }
124 
 
125 
 
161 pfowler 126 
    public abstract class Control {
166 pfowler 127 
        public UInt64 value { get; set; }
162 pfowler 128 
 
161 pfowler 129 
        public Control(Command command) {
130 
            commands.Add(command);
131 
        }
132 
 
133 
        public List<Command> commands = new List<Command>();
167 pfowler 134 
        public jsdata data { get; set; }
161 pfowler 135 
        public Boolean updated { get; set; }
136 
 
137 
        public abstract void Tick();
138 
    }
139 
 
140 
    public class Switch2Pos : Control {
141 
        public int pin { get; set; }
162 pfowler 142 
 
161 pfowler 143 
        public Boolean invert { get; set; }
144 
 
145 
        public Switch2Pos(Command command, int pin, Boolean invert = false) : base(command) {
146 
            this.invert = invert;
147 
            this.pin = pin;
148 
        }
149 
 
150 
        public override void Tick() {
166 pfowler 151 
            UInt64 chg = (UInt64)(data.prev >> pin) & 0x01;
167 pfowler 152 
            UInt64 norm = (UInt64)(data.buttons >> pin) & 0x01;
161 pfowler 153 
            this.value = 0;
166 pfowler 154 
 
155 
            if ((UInt64)(norm) == 1) {
156 
                value = (UInt64)(invert ? 0 : 1);
161 pfowler 157 
            } else {
166 pfowler 158 
                value = (UInt64)(invert ? 1 : 0);
161 pfowler 159 
            }
160 
 
162 pfowler 161 
            if (this.commands != null && norm != chg) {
161 pfowler 162 
                foreach (Command cmd in this.commands) {
162 pfowler 163 
                    cmd.data = this.data;
164 pfowler 164 
                    if (cmd.Send(this.value) == 0)
165 
                        Console.Write(cmd.ToString());
161 pfowler 166 
                }
167 
            }
168 
        }
169 
    }
170 
 
171 
    public class Switch3Pos : Control {
172 
        public int pin0 { get; set; }
173 
        public int pin1 { get; set; }
162 pfowler 174 
 
161 pfowler 175 
        public Boolean invert { get; set; }
176 
 
177 
        public Switch3Pos(Command command, int pin0, int pin1, Boolean invert = false) : base(command) {
178 
            this.pin0 = pin0;
179 
            this.pin1 = pin1;
180 
            this.invert = invert;
181 
 
182 
        }
183 
 
184 
        public override void Tick() {
166 pfowler 185 
            UInt64 chg0 = (UInt64)(data.prev >> pin0) & 0x01;
186 
            UInt64 chg1 = (UInt64)(data.prev >> pin1) & 0x01;
167 pfowler 187 
            UInt64 nrm0 = (UInt64)(data.buttons >> pin0) & 0x01;
188 
            UInt64 nrm1 = (UInt64)(data.buttons >> pin1) & 0x01;
161 pfowler 189 
            this.value = 1;
166 pfowler 190 
 
191 
            if ((UInt64)nrm0 == 1)
192 
                this.value = (UInt64)(invert ? 2 : 0);
161 pfowler 193 
            else if ((uint)nrm1 == 1)
166 pfowler 194 
                this.value = (UInt64)(invert ? 0 : 2);
162 pfowler 195 
 
196 
            if (this.commands != null &&  ((nrm0 != chg0) || (nrm1 != chg1))) {
161 pfowler 197 
                foreach (Command cmd in this.commands) {
162 pfowler 198 
                    cmd.data = this.data;
164 pfowler 199 
                    if (cmd.Send(this.value) == 0)
200 
                        Console.Write(cmd.ToString());
161 pfowler 201 
                }
202 
            }
203 
        }
204 
    }
205 
 
167 pfowler 206 
    public class Potentiometer : Control {
207 
        public int channel { get; set; }
208 
 
209 
        public Boolean invert { get; set; }
210 
 
211 
        public Potentiometer(Command command, int channel) : base(command) {
212 
            this.channel = channel;
213 
        }
214 
 
215 
        public override void Tick() {
216 
            UInt16 tmpval = 0;
168 pfowler 217 
            bool changed = data.axis[channel].getPosition(ref tmpval);
167 pfowler 218 
            this.value = tmpval;
180 pfowler 219 
 
167 pfowler 220 
 
168 pfowler 221 
            if (changed) {
167 pfowler 222 
                foreach (Command cmd in this.commands) {
223 
                    cmd.data = this.data;
224 
                    if (cmd.Send(this.value) == 0)
225 
                        Console.Write(cmd.ToString());
226 
                }
227 
            }
228 
        }
229 
    }
230 
 
161 pfowler 231 
    public class Selector : Control {
232 
        int[] pins;
233 
 
162 pfowler 234 
 
161 pfowler 235 
        public Selector(Command command, int[] pins) : base(command) {
236 
            this.pins = pins;
237 
            this.value = 0;
238 
        }
239 
 
240 
        public override void Tick() {
162 pfowler 241 
            // This is a rather complicated way  to check what the previous select
242 
            //  was, and was the current selection is. Not really needed, but hoping it
243 
            //  might come in handy for something else down the line.
166 pfowler 244 
            UInt64 chg = 0;
245 
            UInt64 norm = 0;
246 
            UInt64 mask = 0;
162 pfowler 247 
            for (int i = 0; i < pins.Length; i++) // Create a mask of how many selection points there are
166 pfowler 248 
                mask |= (UInt64)1 << i;
161 pfowler 249 
 
250 
            for (int i = 0; i < pins.Length; i++) {
166 pfowler 251 
                chg |= (UInt64)(data.prev >> (pins[i] - i)); // Narrow down to the previsouly selected bit
167 pfowler 252 
                norm |= (UInt64)(data.buttons >> (pins[i] - i)); // Narrow down to the currently selected bit
161 pfowler 253 
 
167 pfowler 254 
                if ((UInt64)((data.buttons >> pins[i]) & 0x01) == 1) { // Decode the value we need to use
166 pfowler 255 
                    value = (UInt64)i;
161 pfowler 256 
                }
257 
            }
162 pfowler 258 
 
259 
            norm &= mask; // Remove any bits from above
161 pfowler 260 
            chg &= mask;
162 pfowler 261 
 
262 
            if (norm == 0) // Can sometimes be in the inbetween selector switch, ignore
161 pfowler 263 
                return;
264 
 
162 pfowler 265 
            if (norm != chg) { // Send the update if needed
161 pfowler 266 
                foreach (Command cmd in this.commands) {
162 pfowler 267 
                    cmd.data = this.data;
164 pfowler 268 
                    if (cmd.Send(this.value) == 0)
269 
                        Console.Write(cmd.ToString());
161 pfowler 270 
                }
271 
            }
272 
        }
162 pfowler 273 
 
161 pfowler 274 
    }
275 
}