Subversion Repositories group.electronics

Rev

Rev 172 | Rev 175 | 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
 
81
        public uint value { get; set; }
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)) {
173 pfowler 102
 
172 pfowler 103
                this.value = (UInt16)((data & mask) >> shift);
171 pfowler 104
 
172 pfowler 105
                if (this.value == 1)
173 pfowler 106
                    Globals.setBit(ref shadow, this.pin);
172 pfowler 107
                else
173 pfowler 108
                    Globals.clearBit(ref shadow, this.pin);
171 pfowler 109
            }
110
 
172 pfowler 111
            if (tmpshadow == shadow)
112
                return false;
113
 
171 pfowler 114
            return true;
115
        }
116
 
117
    }
118
 
119
 
161 pfowler 120
    public abstract class Control {
166 pfowler 121
        public UInt64 value { get; set; }
162 pfowler 122
 
161 pfowler 123
        public Control(Command command) {
124
            commands.Add(command);
125
        }
126
 
127
        public List<Command> commands = new List<Command>();
167 pfowler 128
        public jsdata data { get; set; }
161 pfowler 129
        public Boolean updated { get; set; }
130
 
131
        public abstract void Tick();
132
    }
133
 
134
    public class Switch2Pos : Control {
135
        public int pin { get; set; }
162 pfowler 136
 
161 pfowler 137
        public Boolean invert { get; set; }
138
 
139
        public Switch2Pos(Command command, int pin, Boolean invert = false) : base(command) {
140
            this.invert = invert;
141
            this.pin = pin;
142
        }
143
 
144
        public override void Tick() {
166 pfowler 145
            UInt64 chg = (UInt64)(data.prev >> pin) & 0x01;
167 pfowler 146
            UInt64 norm = (UInt64)(data.buttons >> pin) & 0x01;
161 pfowler 147
            this.value = 0;
166 pfowler 148
 
149
            if ((UInt64)(norm) == 1) {
150
                value = (UInt64)(invert ? 0 : 1);
161 pfowler 151
            } else {
166 pfowler 152
                value = (UInt64)(invert ? 1 : 0);
161 pfowler 153
            }
154
 
162 pfowler 155
            if (this.commands != null && norm != chg) {
161 pfowler 156
                foreach (Command cmd in this.commands) {
162 pfowler 157
                    cmd.data = this.data;
164 pfowler 158
                    if (cmd.Send(this.value) == 0)
159
                        Console.Write(cmd.ToString());
161 pfowler 160
                }
161
            }
162
        }
163
    }
164
 
165
    public class Switch3Pos : Control {
166
        public int pin0 { get; set; }
167
        public int pin1 { get; set; }
162 pfowler 168
 
161 pfowler 169
        public Boolean invert { get; set; }
170
 
171
        public Switch3Pos(Command command, int pin0, int pin1, Boolean invert = false) : base(command) {
172
            this.pin0 = pin0;
173
            this.pin1 = pin1;
174
            this.invert = invert;
175
 
176
        }
177
 
178
        public override void Tick() {
166 pfowler 179
            UInt64 chg0 = (UInt64)(data.prev >> pin0) & 0x01;
180
            UInt64 chg1 = (UInt64)(data.prev >> pin1) & 0x01;
167 pfowler 181
            UInt64 nrm0 = (UInt64)(data.buttons >> pin0) & 0x01;
182
            UInt64 nrm1 = (UInt64)(data.buttons >> pin1) & 0x01;
161 pfowler 183
            this.value = 1;
166 pfowler 184
 
185
            if ((UInt64)nrm0 == 1)
186
                this.value = (UInt64)(invert ? 2 : 0);
161 pfowler 187
            else if ((uint)nrm1 == 1)
166 pfowler 188
                this.value = (UInt64)(invert ? 0 : 2);
162 pfowler 189
 
190
            if (this.commands != null &&  ((nrm0 != chg0) || (nrm1 != chg1))) {
161 pfowler 191
                foreach (Command cmd in this.commands) {
162 pfowler 192
                    cmd.data = this.data;
164 pfowler 193
                    if (cmd.Send(this.value) == 0)
194
                        Console.Write(cmd.ToString());
161 pfowler 195
                }
196
            }
197
        }
198
    }
199
 
167 pfowler 200
    public class Potentiometer : Control {
201
        public int channel { get; set; }
202
 
203
        public Boolean invert { get; set; }
204
 
205
        public Potentiometer(Command command, int channel) : base(command) {
206
            this.channel = channel;
207
        }
208
 
209
        public override void Tick() {
210
            UInt16 tmpval = 0;
168 pfowler 211
            bool changed = data.axis[channel].getPosition(ref tmpval);
167 pfowler 212
            this.value = tmpval;
213
 
214
 
168 pfowler 215
            if (changed) {
167 pfowler 216
                foreach (Command cmd in this.commands) {
217
                    cmd.data = this.data;
218
                    if (cmd.Send(this.value) == 0)
219
                        Console.Write(cmd.ToString());
220
                }
221
            }
222
        }
223
    }
224
 
161 pfowler 225
    public class Selector : Control {
226
        int[] pins;
227
 
162 pfowler 228
 
161 pfowler 229
        public Selector(Command command, int[] pins) : base(command) {
230
            this.pins = pins;
231
            this.value = 0;
232
        }
233
 
234
        public override void Tick() {
162 pfowler 235
            // This is a rather complicated way  to check what the previous select
236
            //  was, and was the current selection is. Not really needed, but hoping it 
237
            //  might come in handy for something else down the line.
166 pfowler 238
            UInt64 chg = 0;
239
            UInt64 norm = 0;
240
            UInt64 mask = 0;
162 pfowler 241
            for (int i = 0; i < pins.Length; i++) // Create a mask of how many selection points there are
166 pfowler 242
                mask |= (UInt64)1 << i;
161 pfowler 243
 
244
            for (int i = 0; i < pins.Length; i++) {
166 pfowler 245
                chg |= (UInt64)(data.prev >> (pins[i] - i)); // Narrow down to the previsouly selected bit
167 pfowler 246
                norm |= (UInt64)(data.buttons >> (pins[i] - i)); // Narrow down to the currently selected bit
161 pfowler 247
 
167 pfowler 248
                if ((UInt64)((data.buttons >> pins[i]) & 0x01) == 1) { // Decode the value we need to use
166 pfowler 249
                    value = (UInt64)i;
161 pfowler 250
                }
251
            }
162 pfowler 252
 
253
            norm &= mask; // Remove any bits from above
161 pfowler 254
            chg &= mask;
162 pfowler 255
 
256
            if (norm == 0) // Can sometimes be in the inbetween selector switch, ignore
161 pfowler 257
                return;
258
 
162 pfowler 259
            if (norm != chg) { // Send the update if needed
161 pfowler 260
                foreach (Command cmd in this.commands) {
162 pfowler 261
                    cmd.data = this.data;
164 pfowler 262
                    if (cmd.Send(this.value) == 0)
263
                        Console.Write(cmd.ToString());
161 pfowler 264
                }
265
            }
266
        }
162 pfowler 267
 
161 pfowler 268
    }
269
}