Контроллер усилителя на AVR.
- Войдите на сайт для отправки комментариев
Втр, 24/12/2013 - 14:17
Здравствуйте товарищи! Пишу сюда надеюсь что ко ни будь, поможет.
Хочу собрать усилитель в А-классе со встроенным USB ЦАП. На передней панели хотел расположить кнопки управление мультимедией и экран, на котором бы писались контрольные данные по температуре, напряжению и данные о воспроизводимой в данной момент песни. Предполагается внутри усилителя расположить хаб в которому подключается наш AVR контроллер и ЦАП.
Я уже создавал тему форуме, но сам так и не смог разобраться. Поэтому мне нужна помощь человека, который разбирается во всем этом. По поводу вознаграждения договоримся.
PS/ Если кто, то считает что для моей задумки подойдёт другой МК я возражать не буду.
Скайп LEVV2008
Так что? Никто не знает, как с USB работать?
https://www.google.com/search?hl=ru&q=USB+%D0%A6%D0%90%D0%9F
Так цап отдельной микросхемой! А контроллер для управление монитором и мультимедией на ПК через USB.
Так цап отдельной микросхемой! А контроллер для управление монитором и мультимедией на ПК через USB.
верно. цап - одной микросхемой, для управления монитором и мультимедией - клавиатура и мышь второй микросхемой.
Тогда я совершенно не понял, что вы хотели сказать этой ссылкой. С цапом проблемы нет. Проблема в написании кода общения между МК и ПК по USB. Я просмотрел уже сотни ссылок по AVR Hid. Но так и не понял как написать код
Тогда я совершенно не понял, что вы хотели сказать этой ссылкой. С цапом проблемы нет.
если нет, то почему спрашиваете?
Проблема в написании кода общения между МК и ПК по USB. Я просмотрел уже сотни ссылок по AVR Hid. Но так и не понял как написать код
в папке *\arduino-1.0.5\examples\09.USB рабочие примеры.
Примеры то для Arduino Leonardo
Примеры то для Arduino Leonardo
ну, да - только у Леонардо есть хардварный USB, у остальных виртуализация COM-порта на USB.
всё, что можете делать с компортом, вам доступно - принимать, отсылать в/из системы/дуины, не более.
как иное USB-устройство в системе видеться не может.
Может! Если знать как.
Может! Если знать как.
курите даташиты на железо дуино, если уверены в своей правоте.
Всем привет! Хотел бы продолжить данную тему. Я немного забросил этот проект, но решил к нему вернуть пару дней назад. Хочу с вами поделиться информацией, так как её найти достаточно сложно. Так пусть же она останется здесь.
Администратор! Пожалуйста, перенеси тему в ветку по программированию и удали лишние сообщения!
Собственно то, что я хочу сказать. Подключить контроллер по USB можно 2 способами.
1) Это программная эмуляция протокола USB. Я это делал и мне показался этот способ очень сложным и мало эффективным. Так как на контролер накладываются определённые условия и чтобы всё настроить надо очень хорошо разбираться в программировании. В общем, для тех, кто знает только язык программирования Arduno (Wiring) не вариант.
http://www.obdev.at/products/vusb/index.html
http://habrahabr.ru/post/125253/
http://we.easyelectronics.ru/electro-and-pc/usb-dlya-avr-chast-2-hid-class-na-v-usb.html
2) А вот это достаточно интересно и просто. Нудно использовать контроллер с аппаратной поддержкой USB. Такой как, например arduino leonardo. Так как мне необходимо использовать только кнопки мультимедии а в стандартной библиотеке такого нет то путём поисков наткнулся на этот сайт. http://stefanjones.ca/blog/arduino-leonardo-remote-multimedia-keys/ . В нём написано как добавить эти кнопки. Но можно поступить проще я прикреплю уже исправленные файлы, которые необходимо просто переместить с заменой.
В общем и целом мне удалось найти информацию и реализовать мультимедийные клавиши. Но теперь встал вопрос, как посылать данные с ПК на контролер…. Есть ли у вас соображения по этому поводу? Так как такое сочетание не работает.
1
if
(Keyboard.available()) {
2
byte
dat = Keyboard.read();
3
}
А жыль :((
HID
001
/* Copyright (c) 2011, Peter Barrett
002
**
003
** Permission to use, copy, modify, and/or distribute this software for
004
** any purpose with or without fee is hereby granted, provided that the
005
** above copyright notice and this permission notice appear in all copies.
006
**
007
** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
008
** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
009
** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
010
** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
011
** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
012
** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
013
** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
014
** SOFTWARE.
015
*/
016
017
#include "Platform.h"
018
#include "USBAPI.h"
019
#include "USBDesc.h"
020
021
#if defined(USBCON)
022
#ifdef HID_ENABLED
023
024
//#define RAWHID_ENABLED
025
026
// Singletons for mouse, keyboard and remote
027
028
Mouse_ Mouse;
029
Keyboard_ Keyboard;
030
Remote_ Remote;
031
032
//================================================================================
033
//================================================================================
034
035
// HID report descriptor
036
037
#define LSB(_x) ((_x) & 0xFF)
038
#define MSB(_x) ((_x) >> 8)
039
040
#define RAWHID_USAGE_PAGE 0xFFC0
041
#define RAWHID_USAGE 0x0C00
042
#define RAWHID_TX_SIZE 64
043
#define RAWHID_RX_SIZE 64
044
045
extern
const
u8 _hidReportDescriptor[] PROGMEM;
046
const
u8 _hidReportDescriptor[] = {
047
048
// Mouse
049
0x05, 0x01,
// USAGE_PAGE (Generic Desktop) // 54
050
0x09, 0x02,
// USAGE (Mouse)
051
0xa1, 0x01,
// COLLECTION (Application)
052
0x09, 0x01,
// USAGE (Pointer)
053
0xa1, 0x00,
// COLLECTION (Physical)
054
0x85, 0x01,
// REPORT_ID (1)
055
0x05, 0x09,
// USAGE_PAGE (Button)
056
0x19, 0x01,
// USAGE_MINIMUM (Button 1)
057
0x29, 0x03,
// USAGE_MAXIMUM (Button 3)
058
0x15, 0x00,
// LOGICAL_MINIMUM (0)
059
0x25, 0x01,
// LOGICAL_MAXIMUM (1)
060
0x95, 0x03,
// REPORT_COUNT (3)
061
0x75, 0x01,
// REPORT_SIZE (1)
062
0x81, 0x02,
// INPUT (Data,Var,Abs)
063
0x95, 0x01,
// REPORT_COUNT (1)
064
0x75, 0x05,
// REPORT_SIZE (5)
065
0x81, 0x03,
// INPUT (Cnst,Var,Abs)
066
0x05, 0x01,
// USAGE_PAGE (Generic Desktop)
067
0x09, 0x30,
// USAGE (X)
068
0x09, 0x31,
// USAGE (Y)
069
0x09, 0x38,
// USAGE (Wheel)
070
0x15, 0x81,
// LOGICAL_MINIMUM (-127)
071
0x25, 0x7f,
// LOGICAL_MAXIMUM (127)
072
0x75, 0x08,
// REPORT_SIZE (8)
073
0x95, 0x03,
// REPORT_COUNT (3)
074
0x81, 0x06,
// INPUT (Data,Var,Rel)
075
0xc0,
// END_COLLECTION
076
0xc0,
// END_COLLECTION
077
078
// Keyboard
079
0x05, 0x01,
// USAGE_PAGE (Generic Desktop) // 47
080
0x09, 0x06,
// USAGE (Keyboard)
081
0xa1, 0x01,
// COLLECTION (Application)
082
0x85, 0x02,
// REPORT_ID (2)
083
0x05, 0x07,
// USAGE_PAGE (Keyboard)
084
085
0x19, 0xe0,
// USAGE_MINIMUM (Keyboard LeftControl)
086
0x29, 0xe7,
// USAGE_MAXIMUM (Keyboard Right GUI)
087
0x15, 0x00,
// LOGICAL_MINIMUM (0)
088
0x25, 0x01,
// LOGICAL_MAXIMUM (1)
089
0x75, 0x01,
// REPORT_SIZE (1)
090
091
0x95, 0x08,
// REPORT_COUNT (8)
092
0x81, 0x02,
// INPUT (Data,Var,Abs)
093
0x95, 0x01,
// REPORT_COUNT (1)
094
0x75, 0x08,
// REPORT_SIZE (8)
095
0x81, 0x03,
// INPUT (Cnst,Var,Abs)
096
097
0x95, 0x06,
// REPORT_COUNT (6)
098
0x75, 0x08,
// REPORT_SIZE (8)
099
0x15, 0x00,
// LOGICAL_MINIMUM (0)
100
0x25, 0x65,
// LOGICAL_MAXIMUM (101)
101
0x05, 0x07,
// USAGE_PAGE (Keyboard)
102
103
0x19, 0x00,
// USAGE_MINIMUM (Reserved (no event indicated))
104
0x29, 0x65,
// USAGE_MAXIMUM (Keyboard Application)
105
0x81, 0x00,
// INPUT (Data,Ary,Abs)
106
0xc0,
// END_COLLECTION
107
108
#if RAWHID_ENABLED
109
// RAW HID
110
0x06, LSB(RAWHID_USAGE_PAGE), MSB(RAWHID_USAGE_PAGE),
// 30
111
0x0A, LSB(RAWHID_USAGE), MSB(RAWHID_USAGE),
112
113
0xA1, 0x01,
// Collection 0x01
114
0x85, 0x03,
// REPORT_ID (3)
115
0x75, 0x08,
// report size = 8 bits
116
0x15, 0x00,
// logical minimum = 0
117
0x26, 0xFF, 0x00,
// logical maximum = 255
118
119
0x95, 64,
// report count TX
120
0x09, 0x01,
// usage
121
0x81, 0x02,
// Input (array)
122
123
0x95, 64,
// report count RX
124
0x09, 0x02,
// usage
125
0x91, 0x02,
// Output (array)
126
0xC0,
// end collection
127
#endif
128
129
//-----------------------------------------------------------------------------
130
131
/* Cross-platform support for controls found on IR Remotes */
132
133
0x05, 0x0c,
// Usage Page (Consumer Devices)
134
0x09, 0x01,
// Usage (Consumer Control)
135
0xa1, 0x01,
// Collection (Application)
136
0x85, 0x04,
// REPORT_ID (4)
137
0x15, 0x00,
// Logical Minimum (0)
138
0x25, 0x01,
// Logical Maximum (1)
139
0x09, 0xe9,
// Usage (Volume Up)
140
0x09, 0xea,
// Usage (Volume Down)
141
0x75, 0x01,
// Report Size (1)
142
0x95, 0x02,
// Report Count (2)
143
0x81, 0x06,
// Input (Data, Variable, Relative)
144
145
0x09, 0xe2,
// Usage (Mute)
146
0x95, 0x01,
// Report Count (1)
147
0x81, 0x06,
// Input (Data, Variable, Relative)
148
149
0x09, 0xb0,
// Usage (Play)
150
0x95, 0x01,
// Report Count (1)
151
0x81, 0x06,
// Input (Data, Variable, Relative)
152
153
0x09, 0xb1,
// Usage (Pause)
154
0x95, 0x01,
// Report Count (1)
155
0x81, 0x06,
// Input (Data, Variable, Relative)
156
157
0x09, 0xb7,
// Usage (Stop)
158
0x95, 0x01,
// Report Count (1)
159
0x81, 0x06,
// Input (Data, Variable, Relative)
160
161
0x09, 0xb5,
// Usage (Next)
162
0x95, 0x01,
// Report Count (1)
163
0x81, 0x06,
// Input (Data, Variable, Relative)
164
165
0x09, 0xb6,
// Usage (Previous)
166
0x95, 0x01,
// Report Count (1)
167
0x81, 0x06,
// Input (Data, Variable, Relative)
168
169
0x09, 0xb3,
// Usage (Fast Forward)
170
0x95, 0x01,
// Report Count (1)
171
0x81, 0x06,
// Input (Data, Variable, Relative)
172
173
0x09, 0xb4,
// Usage (Rewind)
174
0x95, 0x01,
// Report Count (1)
175
0x81, 0x06,
// Input (Data, Variable, Relative)
176
177
0x95, 0x06,
// Report Count (6) Number of bits remaining in byte
178
0x81, 0x07,
// Input (Constant, Variable, Relative)
179
0xc0
//End Collection
180
181
};
182
183
extern
const
HIDDescriptor _hidInterface PROGMEM;
184
const
HIDDescriptor _hidInterface =
185
{
186
D_INTERFACE(HID_INTERFACE,1,3,0,0),
187
D_HIDREPORT(
sizeof
(_hidReportDescriptor)),
188
D_ENDPOINT(USB_ENDPOINT_IN (HID_ENDPOINT_INT),USB_ENDPOINT_TYPE_INTERRUPT,0x40,0x01)
189
};
190
191
//================================================================================
192
//================================================================================
193
// Driver
194
195
u8 _hid_protocol = 1;
196
u8 _hid_idle = 1;
197
198
#define WEAK __attribute__ ((weak))
199
200
int
WEAK HID_GetInterface(u8* interfaceNum)
201
{
202
interfaceNum[0] += 1;
// uses 1
203
return
USB_SendControl(TRANSFER_PGM,&_hidInterface,
sizeof
(_hidInterface));
204
}
205
206
int
WEAK HID_GetDescriptor(
int
i)
207
{
208
return
USB_SendControl(TRANSFER_PGM,_hidReportDescriptor,
sizeof
(_hidReportDescriptor));
209
}
210
211
void
WEAK HID_SendReport(u8 id,
const
void
* data,
int
len)
212
{
213
USB_Send(HID_TX, &id, 1);
214
USB_Send(HID_TX | TRANSFER_RELEASE,data,len);
215
}
216
217
bool
WEAK HID_Setup(Setup&
setup
)
218
{
219
u8 r =
setup
.bRequest;
220
u8 requestType =
setup
.bmRequestType;
221
if
(REQUEST_DEVICETOHOST_CLASS_INTERFACE == requestType)
222
{
223
if
(HID_GET_REPORT == r)
224
{
225
//HID_GetReport();
226
return
true
;
227
}
228
if
(HID_GET_PROTOCOL == r)
229
{
230
//Send8(_hid_protocol); // TODO
231
return
true
;
232
}
233
}
234
235
if
(REQUEST_HOSTTODEVICE_CLASS_INTERFACE == requestType)
236
{
237
if
(HID_SET_PROTOCOL == r)
238
{
239
_hid_protocol =
setup
.wValueL;
240
return
true
;
241
}
242
243
if
(HID_SET_IDLE == r)
244
{
245
_hid_idle =
setup
.wValueL;
246
return
true
;
247
}
248
}
249
return
false
;
250
}
251
252
//================================================================================
253
//================================================================================
254
// Mouse
255
256
Mouse_::Mouse_(
void
) : _buttons(0)
257
{
258
}
259
260
void
Mouse_::begin(
void
)
261
{
262
}
263
264
void
Mouse_::end(
void
)
265
{
266
}
267
268
void
Mouse_::click(uint8_t b)
269
{
270
_buttons = b;
271
move(0,0,0);
272
_buttons = 0;
273
move(0,0,0);
274
}
275
276
void
Mouse_::move(signed
char
x, signed
char
y, signed
char
wheel)
277
{
278
u8 m[4];
279
m[0] = _buttons;
280
m[1] = x;
281
m[2] = y;
282
m[3] = wheel;
283
HID_SendReport(1,m,4);
284
}
285
286
void
Mouse_::buttons(uint8_t b)
287
{
288
if
(b != _buttons)
289
{
290
_buttons = b;
291
move(0,0,0);
292
}
293
}
294
295
void
Mouse_::press(uint8_t b)
296
{
297
buttons(_buttons | b);
298
}
299
300
void
Mouse_::release(uint8_t b)
301
{
302
buttons(_buttons & ~b);
303
}
304
305
bool
Mouse_::isPressed(uint8_t b)
306
{
307
if
((b & _buttons) > 0)
308
return
true
;
309
return
false
;
310
}
311
312
//================================================================================
313
//================================================================================
314
// Keyboard
315
316
Keyboard_::Keyboard_(
void
)
317
{
318
}
319
320
void
Keyboard_::begin(
void
)
321
{
322
}
323
324
void
Keyboard_::end(
void
)
325
{
326
}
327
328
void
Keyboard_::sendReport(KeyReport* keys)
329
{
330
HID_SendReport(2,keys,
sizeof
(KeyReport));
331
}
332
333
extern
334
const
uint8_t _asciimap[128] PROGMEM;
335
336
#define SHIFT 0x80
337
const
uint8_t _asciimap[128] =
338
{
339
0x00,
// NUL
340
0x00,
// SOH
341
0x00,
// STX
342
0x00,
// ETX
343
0x00,
// EOT
344
0x00,
// ENQ
345
0x00,
// ACK
346
0x00,
// BEL
347
0x2a,
// BS Backspace
348
0x2b,
// TAB Tab
349
0x28,
// LF Enter
350
0x00,
// VT
351
0x00,
// FF
352
0x00,
// CR
353
0x00,
// SO
354
0x00,
// SI
355
0x00,
// DEL
356
0x00,
// DC1
357
0x00,
// DC2
358
0x00,
// DC3
359
0x00,
// DC4
360
0x00,
// NAK
361
0x00,
// SYN
362
0x00,
// ETB
363
0x00,
// CAN
364
0x00,
// EM
365
0x00,
// SUB
366
0x00,
// ESC
367
0x00,
// FS
368
0x00,
// GS
369
0x00,
// RS
370
0x00,
// US
371
372
0x2c,
// ' '
373
0x1e|SHIFT,
// !
374
0x34|SHIFT,
// "
375
0x20|SHIFT,
// #
376
0x21|SHIFT,
// $
377
0x22|SHIFT,
// %
378
0x24|SHIFT,
// &
379
0x34,
// '
380
0x26|SHIFT,
// (
381
0x27|SHIFT,
// )
382
0x25|SHIFT,
// *
383
0x2e|SHIFT,
// +
384
0x36,
// ,
385
0x2d,
// -
386
0x37,
// .
387
0x38,
// /
388
0x27,
// 0
389
0x1e,
// 1
390
0x1f,
// 2
391
0x20,
// 3
392
0x21,
// 4
393
0x22,
// 5
394
0x23,
// 6
395
0x24,
// 7
396
0x25,
// 8
397
0x26,
// 9
398
0x33|SHIFT,
// :
399
0x33,
// ;
400
0x36|SHIFT,
// <
401
0x2e,
// =
402
0x37|SHIFT,
// >
403
0x38|SHIFT,
// ?
404
0x1f|SHIFT,
// @
405
0x04|SHIFT,
// A
406
0x05|SHIFT,
// B
407
0x06|SHIFT,
// C
408
0x07|SHIFT,
// D
409
0x08|SHIFT,
// E
410
0x09|SHIFT,
// F
411
0x0a|SHIFT,
// G
412
0x0b|SHIFT,
// H
413
0x0c|SHIFT,
// I
414
0x0d|SHIFT,
// J
415
0x0e|SHIFT,
// K
416
0x0f|SHIFT,
// L
417
0x10|SHIFT,
// M
418
0x11|SHIFT,
// N
419
0x12|SHIFT,
// O
420
0x13|SHIFT,
// P
421
0x14|SHIFT,
// Q
422
0x15|SHIFT,
// R
423
0x16|SHIFT,
// S
424
0x17|SHIFT,
// T
425
0x18|SHIFT,
// U
426
0x19|SHIFT,
// V
427
0x1a|SHIFT,
// W
428
0x1b|SHIFT,
// X
429
0x1c|SHIFT,
// Y
430
0x1d|SHIFT,
// Z
431
0x2f,
// [
432
0x31,
// bslash
433
0x30,
// ]
434
0x23|SHIFT,
// ^
435
0x2d|SHIFT,
// _
436
0x35,
// `
437
0x04,
// a
438
0x05,
// b
439
0x06,
// c
440
0x07,
// d
441
0x08,
// e
442
0x09,
// f
443
0x0a,
// g
444
0x0b,
// h
445
0x0c,
// i
446
0x0d,
// j
447
0x0e,
// k
448
0x0f,
// l
449
0x10,
// m
450
0x11,
// n
451
0x12,
// o
452
0x13,
// p
453
0x14,
// q
454
0x15,
// r
455
0x16,
// s
456
0x17,
// t
457
0x18,
// u
458
0x19,
// v
459
0x1a,
// w
460
0x1b,
// x
461
0x1c,
// y
462
0x1d,
// z
463
0x2f|SHIFT,
//
464
0x31|SHIFT,
// |
465
0x30|SHIFT,
// }
466
0x35|SHIFT,
// ~
467
0
// DEL
468
};
469
470
uint8_t USBPutChar(uint8_t c);
471
472
// press() adds the specified key (printing, non-printing, or modifier)
473
// to the persistent key report and sends the report. Because of the way
474
// USB HID works, the host acts like the key remains pressed until we
475
// call release(), releaseAll(), or otherwise clear the report and resend.
476
size_t Keyboard_::press(uint8_t k)
477
{
478
uint8_t i;
479
if
(k >= 136) {
// it's a non-printing key (not a modifier)
480
k = k - 136;
481
}
else
if
(k >= 128) {
// it's a modifier key
482
_keyReport.modifiers |= (1<<(k-128));
483
k = 0;
484
}
else
{
// it's a printing key
485
k = pgm_read_byte(_asciimap + k);
486
if
(!k) {
487
setWriteError();
488
return
0;
489
}
490
if
(k & 0x80) {
// it's a capital letter or other character reached with shift
491
_keyReport.modifiers |= 0x02;
// the left shift modifier
492
k &= 0x7F;
493
}
494
}
495
496
// Add k to the key report only if it's not already present
497
// and if there is an empty slot.
498
if
(_keyReport.keys[0] != k && _keyReport.keys[1] != k &&
499
_keyReport.keys[2] != k && _keyReport.keys[3] != k &&
500
_keyReport.keys[4] != k && _keyReport.keys[5] != k) {
501
502
for
(i=0; i<6; i++) {
503
if
(_keyReport.keys[i] == 0x00) {
504
_keyReport.keys[i] = k;
505
break
;
506
}
507
}
508
if
(i == 6) {
509
setWriteError();
510
return
0;
511
}
512
}
513
sendReport(&_keyReport);
514
return
1;
515
}
516
517
// release() takes the specified key out of the persistent key report and
518
// sends the report. This tells the OS the key is no longer pressed and that
519
// it shouldn't be repeated any more.
520
size_t Keyboard_::release(uint8_t k)
521
{
522
uint8_t i;
523
if
(k >= 136) {
// it's a non-printing key (not a modifier)
524
k = k - 136;
525
}
else
if
(k >= 128) {
// it's a modifier key
526
_keyReport.modifiers &= ~(1<<(k-128));
527
k = 0;
528
}
else
{
// it's a printing key
529
k = pgm_read_byte(_asciimap + k);
530
if
(!k) {
531
return
0;
532
}
533
if
(k & 0x80) {
// it's a capital letter or other character reached with shift
534
_keyReport.modifiers &= ~(0x02);
// the left shift modifier
535
k &= 0x7F;
536
}
537
}
538
539
// Test the key report to see if k is present. Clear it if it exists.
540
// Check all positions in case the key is present more than once (which it shouldn't be)
541
for
(i=0; i<6; i++) {
542
if
(0 != k && _keyReport.keys[i] == k) {
543
_keyReport.keys[i] = 0x00;
544
}
545
}
546
547
sendReport(&_keyReport);
548
return
1;
549
}
550
551
void
Keyboard_::releaseAll(
void
)
552
{
553
_keyReport.keys[0] = 0;
554
_keyReport.keys[1] = 0;
555
_keyReport.keys[2] = 0;
556
_keyReport.keys[3] = 0;
557
_keyReport.keys[4] = 0;
558
_keyReport.keys[5] = 0;
559
_keyReport.modifiers = 0;
560
sendReport(&_keyReport);
561
}
562
563
size_t Keyboard_::write(uint8_t c)
564
{
565
uint8_t p = press(c);
// Keydown
566
uint8_t r = release(c);
// Keyup
567
return
(p);
// just return the result of press() since release() almost always returns 1
568
}
569
570
//================================================================================
571
//================================================================================
572
// Remote
573
574
Remote_::Remote_(
void
)
575
{
576
}
577
578
void
Remote_::begin(
void
)
579
{
580
}
581
582
void
Remote_::end(
void
)
583
{
584
}
585
586
void
Remote_::increase(
void
)
587
{
588
u8 m[2];
589
m[0] = VOLUME_UP;
590
m[1] = 0;
591
HID_SendReport(4,m,2);
592
}
593
594
void
Remote_::decrease(
void
)
595
{
596
u8 m[2];
597
m[0] = VOLUME_DOWN;
598
m[1] = 0;
599
HID_SendReport(4,m,2);
600
}
601
602
void
Remote_::mute(
void
)
603
{
604
u8 m[2];
605
m[0] = VOLUME_MUTE;
606
m[1] = 0;
607
HID_SendReport(4,m,2);
608
}
609
610
void
Remote_::play(
void
)
611
{
612
u8 m[2];
613
m[0] = REMOTE_PLAY;
614
m[1] = 0;
615
HID_SendReport(4,m,2);
616
}
617
618
void
Remote_::pause(
void
)
619
{
620
u8 m[2];
621
m[0] = REMOTE_PAUSE;
622
m[1] = 0;
623
HID_SendReport(4,m,2);
624
}
625
626
void
Remote_::stop(
void
)
627
{
628
u8 m[2];
629
m[0] = REMOTE_STOP;
630
m[1] = 0;
631
HID_SendReport(4,m,2);
632
}
633
634
void
Remote_::next(
void
)
635
{
636
u8 m[2];
637
m[0] = REMOTE_NEXT;
638
m[1] = 0;
639
HID_SendReport(4,m,2);
640
}
641
642
void
Remote_::previous(
void
)
643
{
644
u8 m[2];
645
m[0] = REMOTE_PREVIOUS;
646
m[1] = 0;
647
HID_SendReport(4,m,2);
648
}
649
650
void
Remote_::forward(
void
)
651
{
652
u8 m[2];
653
m[0] = 0;
654
m[1] = REMOTE_FAST_FORWARD >> 8;
655
HID_SendReport(4,m,2);
656
}
657
658
void
Remote_::rewind(
void
)
659
{
660
u8 m[2];
661
m[0] = 0;
662
m[1] = REMOTE_REWIND >> 8;
663
HID_SendReport(4,m,2);
664
}
665
666
void
Remote_::clear(
void
)
667
{
668
u8 m[2];
669
m[0] = 0;
670
m[1] = 0;
671
HID_SendReport(4,m,2);
672
}javascript:
void
(0)
673
674
#endif
675
676
#endif /* if defined(USBCON) */
USBAPI
001
#ifndef __USBAPI__
002
#define __USBAPI__
003
004
#if defined(USBCON)
005
006
//================================================================================
007
//================================================================================
008
// USB
009
010
class
USBDevice_
011
{
012
public
:
013
USBDevice_();
014
bool
configured();
015
016
void
attach();
017
void
detach();
// Serial port goes down too...
018
void
poll();
019
};
020
extern
USBDevice_ USBDevice;
021
022
//================================================================================
023
//================================================================================
024
// Serial over CDC (Serial1 is the physical port)
025
026
class
Serial_ :
public
Stream
027
{
028
private
:
029
ring_buffer *_cdc_rx_buffer;
030
public
:
031
void
begin(uint16_t baud_count);
032
void
end(
void
);
033
034
virtual
int
available(
void
);
035
virtual
void
accept(
void
);
036
virtual
int
peek(
void
);
037
virtual
int
read(
void
);
038
virtual
void
flush(
void
);
039
virtual
size_t write(uint8_t);
040
using
Print::write;
// pull in write(str) and write(buf, size) from Print
041
operator
bool
();
042
};
043
extern
Serial_
Serial
;
044
045
//================================================================================
046
//================================================================================
047
// Mouse
048
049
#define MOUSE_LEFT 1
050
#define MOUSE_RIGHT 2
051
#define MOUSE_MIDDLE 4
052
#define MOUSE_ALL (MOUSE_LEFT | MOUSE_RIGHT | MOUSE_MIDDLE)
053
054
class
Mouse_
055
{
056
private
:
057
uint8_t _buttons;
058
void
buttons(uint8_t b);
059
public
:
060
Mouse_(
void
);
061
void
begin(
void
);
062
void
end(
void
);
063
void
click(uint8_t b = MOUSE_LEFT);
064
void
move(signed
char
x, signed
char
y, signed
char
wheel = 0);
065
void
press(uint8_t b = MOUSE_LEFT);
// press LEFT by default
066
void
release(uint8_t b = MOUSE_LEFT);
// release LEFT by default
067
bool
isPressed(uint8_t b = MOUSE_LEFT);
// check LEFT by default
068
};
069
extern
Mouse_ Mouse;
070
071
//================================================================================
072
//================================================================================
073
// Keyboard
074
075
#define KEY_LEFT_CTRL 0x80
076
#define KEY_LEFT_SHIFT 0x81
077
#define KEY_LEFT_ALT 0x82
078
#define KEY_LEFT_GUI 0x83
079
#define KEY_RIGHT_CTRL 0x84
080
#define KEY_RIGHT_SHIFT 0x85
081
#define KEY_RIGHT_ALT 0x86
082
#define KEY_RIGHT_GUI 0x87
083
084
#define KEY_UP_ARROW 0xDA
085
#define KEY_DOWN_ARROW 0xD9
086
#define KEY_LEFT_ARROW 0xD8
087
#define KEY_RIGHT_ARROW 0xD7
088
#define KEY_BACKSPACE 0xB2
089
#define KEY_TAB 0xB3
090
#define KEY_RETURN 0xB0
091
#define KEY_ESC 0xB1
092
#define KEY_INSERT 0xD1
093
#define KEY_DELETE 0xD4
094
#define KEY_PAGE_UP 0xD3
095
#define KEY_PAGE_DOWN 0xD6
096
#define KEY_HOME 0xD2
097
#define KEY_END 0xD5
098
#define KEY_CAPS_LOCK 0xC1
099
#define KEY_F1 0xC2
100
#define KEY_F2 0xC3
101
#define KEY_F3 0xC4
102
#define KEY_F4 0xC5
103
#define KEY_F5 0xC6
104
#define KEY_F6 0xC7
105
#define KEY_F7 0xC8
106
#define KEY_F8 0xC9
107
#define KEY_F9 0xCA
108
#define KEY_F10 0xCB
109
#define KEY_F11 0xCC
110
#define KEY_F12 0xCD
111
112
// Low level key report: up to 6 keys and shift, ctrl etc at once
113
typedef
struct
114
{
115
uint8_t modifiers;
116
uint8_t reserved;
117
uint8_t keys[6];
118
} KeyReport;
119
120
class
Keyboard_ :
public
Print
121
{
122
private
:
123
KeyReport _keyReport;
124
void
sendReport(KeyReport* keys);
125
public
:
126
Keyboard_(
void
);
127
void
begin(
void
);
128
void
end(
void
);
129
virtual
size_t write(uint8_t k);
130
virtual
size_t press(uint8_t k);
131
virtual
size_t release(uint8_t k);
132
virtual
void
releaseAll(
void
);
133
};
134
extern
Keyboard_ Keyboard;
135
136
//================================================================================
137
//================================================================================
138
// Remote
139
140
#define REMOTE_CLEAR 0
141
#define VOLUME_UP 1
142
#define VOLUME_DOWN 2
143
#define VOLUME_MUTE 4
144
#define REMOTE_PLAY 8
145
#define REMOTE_PAUSE 16
146
#define REMOTE_STOP 32
147
#define REMOTE_NEXT 64
148
#define REMOTE_PREVIOUS 128
149
#define REMOTE_FAST_FORWARD 256
150
#define REMOTE_REWIND 512
151
152
class
Remote_
153
{
154
private
:
155
public
:
156
Remote_(
void
);
157
void
begin(
void
);
158
void
end(
void
);
159
160
// Volume
161
void
increase(
void
);
162
void
decrease(
void
);
163
void
mute(
void
);
164
165
// Playback
166
void
play(
void
);
167
void
pause(
void
);
168
void
stop(
void
);
169
170
// Track Controls
171
void
next(
void
);
172
void
previous(
void
);
173
void
forward(
void
);
174
void
rewind(
void
);
175
176
// Send an empty report to prevent repeated actions
177
void
clear(
void
);
178
};
179
extern
Remote_ Remote;
180
//================================================================================
181
//================================================================================
182
// Low level API
183
184
typedef
struct
185
{
186
uint8_t bmRequestType;
187
uint8_t bRequest;
188
uint8_t wValueL;
189
uint8_t wValueH;
190
uint16_t wIndex;
191
uint16_t wLength;
192
} Setup;
193
194
//================================================================================
195
//================================================================================
196
// HID 'Driver'
197
198
int
HID_GetInterface(uint8_t* interfaceNum);
199
int
HID_GetDescriptor(
int
i);
200
bool
HID_Setup(Setup&
setup
);
201
void
HID_SendReport(uint8_t id,
const
void
* data,
int
len);
202
203
//================================================================================
204
//================================================================================
205
// MSC 'Driver'
206
207
int
MSC_GetInterface(uint8_t* interfaceNum);
208
int
MSC_GetDescriptor(
int
i);
209
bool
MSC_Setup(Setup&
setup
);
210
bool
MSC_Data(uint8_t rx,uint8_t tx);
211
212
//================================================================================
213
//================================================================================
214
// CSC 'Driver'
215
216
int
CDC_GetInterface(uint8_t* interfaceNum);
217
int
CDC_GetDescriptor(
int
i);
218
bool
CDC_Setup(Setup&
setup
);
219
220
//================================================================================
221
//================================================================================
222
223
#define TRANSFER_PGM 0x80
224
#define TRANSFER_RELEASE 0x40
225
#define TRANSFER_ZERO 0x20
226
227
int
USB_SendControl(uint8_t flags,
const
void
* d,
int
len);
228
int
USB_RecvControl(
void
* d,
int
len);
229
230
uint8_t USB_Available(uint8_t ep);
231
int
USB_Send(uint8_t ep,
const
void
* data,
int
len);
// blocking
232
int
USB_Recv(uint8_t ep,
void
* data,
int
len);
// non-blocking
233
int
USB_Recv(uint8_t ep);
// non-blocking
234
void
USB_Flush(uint8_t ep);
235
236
#endif
237
238
#endif /* if defined(USBCON) */