Subversion Repositories svn.mios

Rev

Rev 660 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
628 adamjking 1
/*
2
 * @(#)DebugFunction.java   beta8   2006/04/23
3
 *
4
 * Copyright (C) 2008    Adam King (adamjking@optusnet.com.au)
5
 *
6
 * This application is free software; you can redistribute it and/or modify
7
 * it under the terms of the GNU General Public License as published by
8
 * the Free Software Foundation; either version 2 of the License, or
9
 * (at your option) any later version.
10
 *
11
 * This application is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 * GNU General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU General Public License
17
 * along with this application; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 */
20
 
21
package org.midibox.mios;
22
 
23
import java.io.BufferedReader;
24
import java.io.InputStreamReader;
25
import java.util.Iterator;
26
import java.util.Vector;
27
 
28
import javax.sound.midi.InvalidMidiDataException;
29
import javax.sound.midi.Receiver;
30
import javax.sound.midi.SysexMessage;
31
 
32
import org.midibox.midi.MidiUtils;
33
import org.midibox.utils.ResourceLoader;
34
 
35
public class DebugFunction extends MIOSSysexSendReceive {
36
 
37
    public final static Object MODE = new Object();
38
 
39
    public final static Object DEBUG_FUNCTION_PARAMETERS = new Object();
40
 
41
    public final static Object DELAY_TIME = new Object();
42
 
43
    public final static Object SRAM_READ_ADDRESS = new Object();
44
 
45
    public final static Object SRAM_READ_COUNTER = new Object();
46
 
47
    public final static Object SRAM_WRITE_ADDRESS = new Object();
48
 
49
    public final static Object SRAM_WRITE_DATA = new Object();
50
 
51
    public final static int DEBUG_FUNCTIONS_MODE = 1;
52
 
53
    public final static int SRAM_READ_MODE = 2;
54
 
55
    public final static int SRAM_WRITE_MODE = 3;
56
 
57
    protected int mode;
58
 
59
    protected Vector miosVectorNames;
60
 
61
    protected Vector miosVectorValues;
62
 
63
    protected Vector debugFunctionParameters;
64
 
65
    protected int delayTime;
66
 
67
    protected int sramReadAddress;
68
 
69
    protected int sramReadCounter;
70
 
71
    protected int sramWriteAddress;
72
 
73
    protected int sramWriteData;
74
 
75
    private boolean returnHex;
76
 
77
    private Vector messageParameters;
78
 
79
    private int noReturnValues = 0;
80
 
81
    private int colNo = 0;
82
 
83
    private byte[] dump;
84
 
85
    private int dumpAddress = 0;
86
 
87
    public DebugFunction(Receiver receiver) {
88
        super(receiver);
89
 
90
        this.mode = DEBUG_FUNCTIONS_MODE;
91
 
92
        this.debugFunctionParameters = new Vector();
93
 
94
        this.delayTime = 300;
95
 
96
        this.sramReadAddress = 0;
97
 
98
        this.sramReadCounter = 0;
99
 
100
        this.sramWriteAddress = 0;
101
 
102
        this.sramWriteData = 0;
103
 
104
        importDebugfunctions();
105
    }
106
 
107
    private void importDebugfunctions() {
108
        {
109
            miosVectorNames = new Vector();
110
 
111
            miosVectorValues = new Vector();
112
 
113
            try {
114
                BufferedReader br = new BufferedReader(new InputStreamReader(
115
                        ResourceLoader
116
                                .getResourceAsStream("mios/mios_vectors.inc")));
117
 
118
                String sLine;
119
                while ((sLine = br.readLine()) != null) {
120
 
121
                    if (!sLine.startsWith("MIOS_RESERVED")) {
122
 
123
                        String[] temp = sLine.split("\\s+");
124
 
125
                        miosVectorNames.addElement(temp[0]);
126
 
127
                        miosVectorValues.addElement(Integer.decode(temp[2]));
128
                    }
129
                }
130
            } catch (Exception e) {
131
 
132
            }
133
        }
134
    }
135
 
136
    public Vector getMiosVectorNames() {
137
        return miosVectorNames;
138
    }
139
 
140
    public Vector getMiosVectorValues() {
141
        return miosVectorValues;
142
    }
143
 
144
    public int getDelayTime() {
145
        return delayTime;
146
    }
147
 
148
    public void setDelayTime(int delayTime) {
149
        this.delayTime = delayTime;
150
 
151
        setChanged();
152
        notifyObservers(DELAY_TIME);
153
        clearChanged();
154
    }
155
 
156
    public int getMode() {
157
        return mode;
158
    }
159
 
160
    public void setMode(int mode) {
161
        this.mode = mode;
162
 
163
        setChanged();
164
        notifyObservers(MODE);
165
        clearChanged();
166
    }
167
 
168
    public int getSramReadAddress() {
169
        return sramReadAddress;
170
    }
171
 
727 adamjking 172
    public void setSramReadAddress(int readAddress) {
628 adamjking 173
        this.sramReadAddress = readAddress;
174
 
175
        setChanged();
176
        notifyObservers(SRAM_READ_ADDRESS);
177
        clearChanged();
178
    }
179
 
180
    public int getSramReadCounter() {
181
        return sramReadCounter;
182
    }
183
 
727 adamjking 184
    public void setSramReadCounter(int readCounter) {
628 adamjking 185
        this.sramReadCounter = readCounter;
186
 
187
        setChanged();
188
        notifyObservers(SRAM_READ_COUNTER);
189
        clearChanged();
190
    }
191
 
192
    public int getSramWriteAddress() {
193
        return sramWriteAddress;
194
    }
195
 
727 adamjking 196
    public void setSramWriteAddress(int writeAddress) {
628 adamjking 197
        this.sramWriteAddress = writeAddress;
198
 
199
        setChanged();
200
        notifyObservers(SRAM_WRITE_ADDRESS);
201
        clearChanged();
202
    }
203
 
204
    public int getSramWriteData() {
205
        return sramWriteData;
206
    }
207
 
727 adamjking 208
    public void setSramWriteData(int writeData) {
209
        this.sramWriteData = writeData;
628 adamjking 210
 
211
        setChanged();
212
        notifyObservers(SRAM_WRITE_DATA);
213
        clearChanged();
214
    }
215
 
216
    public Vector getDebugFunctionParameters() {
217
        return debugFunctionParameters;
218
    }
219
 
220
    public void insertDebugFunctionParameters(DebugFunctionParameters params,
221
            int pos) {
222
        if (params != null) {
223
            debugFunctionParameters.insertElementAt(params, pos);
224
        }
225
 
226
        setChanged();
227
        notifyObservers(DEBUG_FUNCTION_PARAMETERS);
228
        clearChanged();
229
    }
230
 
231
    public void insertDebugFunctionParameters(DebugFunctionParameters[] params,
232
            int pos) {
233
        for (int i = params.length - 1; i >= 0; i--) {
234
            insertDebugFunctionParameters(params[i], pos);
235
        }
236
    }
237
 
238
    public void addDebugFunctionParameters(DebugFunctionParameters params) {
239
        insertDebugFunctionParameters(params, debugFunctionParameters.size());
240
    }
241
 
242
    public void addDebugFunctionParameters(DebugFunctionParameters[] params) {
243
        for (int i = params.length - 1; i >= 0; i--) {
244
            addDebugFunctionParameters(params[i]);
245
        }
246
    }
247
 
248
    public DebugFunctionParameters createDebugFunctionParameters() {
249
 
250
        DebugFunctionParameters params = new DebugFunctionParameters();
251
 
252
        addDebugFunctionParameters(params);
253
 
254
        return params;
255
    }
256
 
257
    public void removeDebugFunctionParameters(int paramNo) {
258
 
259
        debugFunctionParameters.removeElementAt(paramNo);
260
 
261
        setChanged();
262
        notifyObservers(DEBUG_FUNCTION_PARAMETERS);
263
        clearChanged();
264
    }
265
 
266
    public void removeDebugFunctionParameters(int[] paramNos) {
267
        for (int i = paramNos.length - 1; i >= 0; i--) {
268
            removeDebugFunctionParameters(paramNos[i]);
269
        }
270
    }
271
 
272
    public void createDebugFunctionsTask(boolean returnHex) {
273
 
274
        Vector messageParameters = new Vector();
275
 
276
        if (mode == DEBUG_FUNCTIONS_MODE) {
277
 
278
            Iterator it = debugFunctionParameters.iterator();
279
 
280
            while (it.hasNext()) {
281
                DebugFunctionParameters params = (DebugFunctionParameters) it
282
                        .next();
283
 
284
                if (params.address != 0) {
285
                    messageParameters.add(params);
286
                }
287
            }
288
 
289
        } else if (mode == SRAM_READ_MODE) {
290
 
291
            DebugFunctionParameters readParameter = new DebugFunctionParameters();
292
 
293
            readParameter.address = sramReadAddress;
294
            readParameter.wreg = sramReadCounter >> 8 & 0xFF;
295
            readParameter.param1 = sramReadCounter & 0xFF;
296
            readParameter.param2 = 0;
297
            readParameter.param3 = 0;
298
 
299
            messageParameters.add(readParameter);
300
 
301
        } else if (mode == SRAM_WRITE_MODE) {
302
 
303
            DebugFunctionParameters writeParameter = new DebugFunctionParameters();
304
 
305
            writeParameter.address = sramWriteAddress;
306
            writeParameter.wreg = sramWriteData;
307
            writeParameter.param1 = 0;
308
            writeParameter.param2 = 0;
309
            writeParameter.param3 = 0;
310
 
311
            messageParameters.add(writeParameter);
312
        }
660 adamjking 313
 
658 adamjking 314
        noReturnValues = 0;
660 adamjking 315
 
628 adamjking 316
        sendMessage(returnHex, messageParameters);
317
    }
318
 
319
    private void sendMessage(boolean returnHex, Vector messageParameters) {
320
 
321
        cancelled = false;
322
 
323
        done = false;
324
 
325
        setChanged();
326
        notifyObservers(WORKER);
327
        clearChanged();
328
 
329
        this.returnHex = returnHex;
330
 
331
        this.messageParameters = messageParameters;
332
 
333
        Iterator it = messageParameters.iterator();
334
 
335
        while (it.hasNext()) {
336
 
337
            DebugFunctionParameters parameters = (DebugFunctionParameters) it
338
                    .next();
339
 
340
            byte[] debugCommandMessage = new byte[20];
341
            debugCommandMessage[0] = (byte) 0xF0;
342
            debugCommandMessage[1] = (byte) 0x00;
343
            debugCommandMessage[2] = (byte) 0x00;
344
            debugCommandMessage[3] = (byte) 0x7E;
345
            debugCommandMessage[4] = (byte) 0x40;
346
            debugCommandMessage[5] = (byte) deviceID; // device-id
347
            debugCommandMessage[6] = (byte) 0x0D;
348
            debugCommandMessage[7] = (byte) mode; // command
349
            debugCommandMessage[8] = (byte) ((parameters.address >> 14) & 0x7f); // au
350
            debugCommandMessage[9] = (byte) ((parameters.address >> 7) & 0x7f); // ah
351
            debugCommandMessage[10] = (byte) ((parameters.address >> 0) & 0x7f); // al
352
            debugCommandMessage[11] = (byte) ((parameters.wreg >> 4) & 0x0f); // wh
353
            debugCommandMessage[12] = (byte) ((parameters.wreg) & 0x0f); // wl
354
            debugCommandMessage[13] = (byte) ((parameters.param1 >> 4) & 0x0f); // mp1h
355
            debugCommandMessage[14] = (byte) ((parameters.param1) & 0x0f); // mp1l
356
            debugCommandMessage[15] = (byte) ((parameters.param2 >> 4) & 0x0f); // mp2h
357
            debugCommandMessage[16] = (byte) ((parameters.param2) & 0x0f); // mp2l
358
            debugCommandMessage[17] = (byte) ((parameters.param3 >> 4) & 0x0f); // mp3h
359
            debugCommandMessage[18] = (byte) ((parameters.param3) & 0x0f); // mp3l
360
            debugCommandMessage[19] = (byte) 0xF7;
361
 
362
            dumpAddress = parameters.address;
363
 
364
            try {
365
                SysexMessage sysExMessage = new SysexMessage();
366
                sysExMessage.setMessage(debugCommandMessage,
367
                        debugCommandMessage.length);
368
 
369
                receiver.send(sysExMessage, -1);
370
            } catch (InvalidMidiDataException ex) {
371
                System.out.println(ex.toString());
372
            }
373
 
374
            try {
375
                Thread.sleep(delayTime);
376
            } catch (InterruptedException e) {
377
                cancelled = true;
378
                addMessage("Upload task interrupted");
379
                return;
380
            }
381
        }
382
    }
383
 
384
    protected void receivedReturnValues(byte[] data) {
385
        String returnValues = "";
386
 
387
        if (mode == 1) {
388
 
389
            int wreg = (int) ((data[6] << 4) | data[7]);
390
            int param1 = (int) ((data[8] << 4) | data[9]);
391
            int param2 = (int) ((data[10] << 4) | data[11]);
392
            int param3 = (int) ((data[12] << 4) | data[13]);
393
 
394
            returnValues += "WREG: "
395
                    + ((returnHex) ? MidiUtils.intToHex(wreg) : MidiUtils
396
                            .getDecimalString(wreg))
397
                    + "    MIOS_PARAM1: "
398
                    + ((returnHex) ? MidiUtils.intToHex(param1) : MidiUtils
399
                            .getDecimalString(param1))
400
                    + "    MIOS_PARAM2: "
401
                    + ((returnHex) ? MidiUtils.intToHex(param2) : MidiUtils
402
                            .getDecimalString(param2))
403
                    + "    MIOS_PARAM3: "
404
                    + ((returnHex) ? MidiUtils.intToHex(param3) : MidiUtils
405
                            .getDecimalString(param3));
406
 
407
            addMessage(returnValues);
408
            noReturnValues++;
409
 
410
            if (noReturnValues >= messageParameters.size()) {
411
                done = true;
412
                addMessage("Done");
413
            }
414
        } else if (mode == 2) {
415
            dump = new byte[sramReadCounter * 2];
416
            int useableBytes = ((data[data.length - 1] == (byte) 0xF7) ? data.length - 1
417
                    : data.length) - 6;
418
            System.arraycopy(data, 6, dump, noReturnValues, useableBytes);
419
            noReturnValues += useableBytes;
420
 
421
            if (noReturnValues == dump.length) {
422
                receivedDump();
423
            }
424
 
425
        } else {
426
            done = true;
427
            addMessage("Received write acknowledgement response");
428
        }
429
    }
430
 
431
    protected void receivedContinuedSysex(byte[] data) {
432
        if (mode == 2) {
433
            int useableBytes = ((data[data.length - 1] == (byte) 0xF7) ? data.length - 1
434
                    : data.length);
435
            System.arraycopy(data, 0, dump, noReturnValues, useableBytes);
436
            noReturnValues += useableBytes;
437
 
438
            if (noReturnValues == dump.length) {
439
                receivedDump();
440
            }
441
        }
442
    }
443
 
444
    private void receivedDump() {
445
 
446
        StringBuffer buffer = new StringBuffer();
447
 
448
        String length = "" + (dumpAddress + dump.length);
449
        length = length.replaceAll(".", "0");
450
 
451
        for (int i = 0; i < dump.length; i += 2) {
452
            int val = (dump[i] << 4 | dump[(i + 1)] & 0xFF);
453
 
454
            if (colNo == 0) {
455
                if (i > 0) {
456
                    buffer.append("\n");
457
                }
458
                buffer.append(length);
459
                String value = ((returnHex) ? Integer.toHexString(
460
                        (dumpAddress + i / 2)).toUpperCase() : ""
461
                        + (dumpAddress + i / 2));
462
                buffer.replace(buffer.length() - value.length(), buffer
463
                        .length(), value);
464
                buffer.append(": ");
465
            }
466
 
467
            buffer.append((returnHex) ? MidiUtils.getHexString(val) : MidiUtils
468
                    .getDecimalString(val));
469
 
470
            if (colNo + 1 == 8) {
471
                buffer.append("  ");
472
            } else if (colNo + 1 < 16) {
473
                buffer.append(" ");
474
            }
475
 
476
            colNo = ++colNo % 16;
477
        }
478
        done = true;
479
        addMessage(buffer.toString() + "\nDone");
480
    }
481
}