Skip to content
Snippets Groups Projects
Commit 1090e767 authored by Dean Camera's avatar Dean Camera
Browse files

Remove incomplete/nonfunctional MIDI class bootloader.

parent 59c4871f
Branches
Tags
No related merge requests found
Expand all Show whitespace changes
Inline Side-by-side
Showing
with 1 addition and 3344 deletions
Bootloaders/Incomplete/MIDI/BootloaderMIDI.c deleted 100644 → 0
+ 0
− 120
View file @ 59c4871f
/*
LUFA Library
Copyright (C) Dean Camera, 2010.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* Main source file for the MIDI bootloader. This file contains the main tasks of the demo and
* is responsible for the initial application hardware configuration.
*/
#include "BootloaderMIDI.h"
/** Main program entry point. This routine configures the hardware required by the application, then
* enters a loop to run the application tasks in sequence.
*/
int main(void)
{
SetupHardware();
for (;;)
{
MIDI_Task();
USB_USBTask();
}
}
/** Configures the board hardware and chip peripherals for the demo's functionality. */
void SetupHardware(void)
{
/* Disable watchdog if enabled by bootloader/fuses */
MCUSR &= ~(1 << WDRF);
wdt_disable();
/* Disable clock division */
clock_prescale_set(clock_div_1);
/* Hardware Initialization */
USB_Init();
}
/** Event handler for the USB_ConfigurationChanged event. This is fired when the host set the current configuration
* of the USB device after enumeration - the device endpoints are configured and the MIDI management task started.
*/
void EVENT_USB_Device_ConfigurationChanged(void)
{
/* Setup MIDI stream endpoints */
Endpoint_ConfigureEndpoint(MIDI_STREAM_OUT_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_OUT, MIDI_STREAM_EPSIZE,
ENDPOINT_BANK_SINGLE);
Endpoint_ConfigureEndpoint(MIDI_STREAM_IN_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_IN, MIDI_STREAM_EPSIZE,
ENDPOINT_BANK_SINGLE);
}
/** Task to handle the generation of MIDI note change events in response to presses of the board joystick, and send them
* to the host.
*/
void MIDI_Task(void)
{
/* Device must be connected and configured for the task to run */
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
/* Select the MIDI OUT stream */
Endpoint_SelectEndpoint(MIDI_STREAM_OUT_EPNUM);
if (Endpoint_IsOUTReceived())
{
USB_MIDI_EventPacket_t InPacket;
Endpoint_Read_Stream_LE(&InPacket, sizeof(InPacket));
Endpoint_ClearOUT();
uint8_t Channel = InPacket.Data1;
uint8_t Data = ((InPacket.Data2 & 0x7F) | ((InPacket.Data3 == 64) ? 0x80 : 0x00));
if ((Channel == MIDI_CONTROL_CHANNEL) && (Data == CONTROL_ENTER_PROG_MODE))
{
USB_MIDI_EventPacket_t MIDIIn = (USB_MIDI_EventPacket_t)
{
.CableNumber = 0,
.Command = (MIDI_COMMAND_NOTE_ON >> 4),
.Data1 = MIDI_COMMAND_NOTE_ON | MIDI_CONTROL_CHANNEL,
.Data2 = CONTROL_DEVICE_READY,
.Data3 = 32,
};
Endpoint_SelectEndpoint(MIDI_STREAM_IN_EPNUM);
Endpoint_Write_Stream_LE(&MIDIIn, sizeof(MIDIIn));
Endpoint_ClearIN();
}
}
}
Bootloaders/Incomplete/MIDI/BootloaderMIDI.h deleted 100644 → 0
+ 0
− 98
View file @ 59c4871f
/*
LUFA Library
Copyright (C) Dean Camera, 2010.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* Header file for AudioOutput.c.
*/
#ifndef _AUDIO_OUTPUT_H_
#define _AUDIO_OUTPUT_H_
/* Includes: */
#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/boot.h>
#include <avr/power.h>
#include <avr/interrupt.h>
#include <stdbool.h>
#include "Descriptors.h"
#include <LUFA/Version.h>
#include <LUFA/Drivers/USB/USB.h>
/* Macros: */
/** MIDI command for a note on (activation) event */
#define MIDI_COMMAND_NOTE_ON 0x90
/** MIDI command for a note off (deactivation) event */
#define MIDI_COMMAND_NOTE_OFF 0x80
#define MIDI_CONTROL_CHANNEL 9
#define MIDI_DATA_CHANNEL 0
#define CONTROL_DEVICE_READY 0xD1
#define CONTROL_ENTER_PROG_MODE 0xDC
#define CONTROL_LEAVE_PROG_MODE 0xDF
#define CONTROL_GET_PAGE_SIZE 0x01
/** LED mask for the library LED driver, to indicate that the USB interface is not ready. */
#define LEDMASK_USB_NOTREADY LEDS_LED1
/** LED mask for the library LED driver, to indicate that the USB interface is enumerating. */
#define LEDMASK_USB_ENUMERATING (LEDS_LED2 | LEDS_LED3)
/** LED mask for the library LED driver, to indicate that the USB interface is ready. */
#define LEDMASK_USB_READY (LEDS_LED2 | LEDS_LED4)
/** LED mask for the library LED driver, to indicate that an error has occurred in the USB interface. */
#define LEDMASK_USB_ERROR (LEDS_LED1 | LEDS_LED3)
/* Type Defines: */
/** Type define for a USB MIDI event packet, used to encapsulate sent and received MIDI messages from a USB MIDI interface. */
typedef struct
{
unsigned char Command : 4; /**< MIDI command being sent or received in the event packet */
unsigned char CableNumber : 4; /**< Virtual cable number of the event being sent or received in the given MIDI interface */
uint8_t Data1; /**< First byte of data in the MIDI event */
uint8_t Data2; /**< Second byte of data in the MIDI event */
uint8_t Data3; /**< Third byte of data in the MIDI event */
} USB_MIDI_EventPacket_t;
/* Function Prototypes: */
void SetupHardware(void);
void MIDI_Task(void);
void EVENT_USB_Device_Connect(void);
void EVENT_USB_Device_Disconnect(void);
void EVENT_USB_Device_ConfigurationChanged(void);
#endif
Bootloaders/Incomplete/MIDI/Descriptors.c deleted 100644 → 0
+ 0
− 325
View file @ 59c4871f
/*
LUFA Library
Copyright (C) Dean Camera, 2010.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* USB Device Descriptors, for library use when in USB device mode. Descriptors are special
* computer-readable structures which the host requests upon device enumeration, to determine
* the device's capabilities and functions.
*/
#include "Descriptors.h"
/** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall
* device characteristics, including the supported USB version, control endpoint size and the
* number of device configurations. The descriptor is read out by the USB host when the enumeration
* process begins.
*/
USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
{
.Header = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
.USBSpecification = VERSION_BCD(01.10),
.Class = 0x00,
.SubClass = 0x00,
.Protocol = 0x00,
.Endpoint0Size = FIXED_CONTROL_ENDPOINT_SIZE,
.VendorID = 0x03EB,
.ProductID = 0x2040,
.ReleaseNumber = 0x0002,
.ManufacturerStrIndex = 0x01,
.ProductStrIndex = 0x02,
.SerialNumStrIndex = NO_DESCRIPTOR,
.NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
};
/** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage
* of the device in one of its supported configurations, including information about any device interfaces
* and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting
* a configuration so that the host may correctly communicate with the USB device.
*/
USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
{
.Config =
{
.Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
.TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
.TotalInterfaces = 2,
.ConfigurationNumber = 1,
.ConfigurationStrIndex = NO_DESCRIPTOR,
.ConfigAttributes = (USB_CONFIG_ATTR_BUSPOWERED | USB_CONFIG_ATTR_SELFPOWERED),
.MaxPowerConsumption = USB_CONFIG_POWER_MA(100)
},
.AudioControlInterface =
{
.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
.InterfaceNumber = 0,
.AlternateSetting = 0,
.TotalEndpoints = 0,
.Class = 0x01,
.SubClass = 0x01,
.Protocol = 0x00,
.InterfaceStrIndex = NO_DESCRIPTOR
},
.AudioControlInterface_SPC =
{
.Header = {.Size = sizeof(USB_Audio_Interface_AC_t), .Type = DTYPE_AudioInterface},
.Subtype = DSUBTYPE_Header,
.ACSpecification = VERSION_BCD(01.00),
.TotalLength = sizeof(USB_Audio_Interface_AC_t),
.InCollection = 1,
.InterfaceNumbers = {1},
},
.AudioStreamInterface =
{
.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
.InterfaceNumber = 1,
.AlternateSetting = 0,
.TotalEndpoints = 2,
.Class = 0x01,
.SubClass = 0x03,
.Protocol = 0x00,
.InterfaceStrIndex = NO_DESCRIPTOR
},
.AudioStreamInterface_SPC =
{
.Header = {.Size = sizeof(USB_Audio_Interface_MIDI_AS_t), .Type = DTYPE_AudioInterface},
.Subtype = DSUBTYPE_General,
.AudioSpecification = VERSION_BCD(01.00),
.TotalLength = (sizeof(USB_Descriptor_Configuration_t) - offsetof(USB_Descriptor_Configuration_t, AudioStreamInterface_SPC))
},
.MIDI_In_Jack_Emb =
{
.Header = {.Size = sizeof(USB_MIDI_In_Jack_t), .Type = DTYPE_AudioInterface},
.Subtype = DSUBTYPE_InputJack,
.JackType = JACKTYPE_EMBEDDED,
.JackID = 0x01,
.JackStrIndex = NO_DESCRIPTOR
},
.MIDI_In_Jack_Ext =
{
.Header = {.Size = sizeof(USB_MIDI_In_Jack_t), .Type = DTYPE_AudioInterface},
.Subtype = DSUBTYPE_InputJack,
.JackType = JACKTYPE_EXTERNAL,
.JackID = 0x02,
.JackStrIndex = NO_DESCRIPTOR
},
.MIDI_Out_Jack_Emb =
{
.Header = {.Size = sizeof(USB_MIDI_Out_Jack_t), .Type = DTYPE_AudioInterface},
.Subtype = DSUBTYPE_OutputJack,
.JackType = JACKTYPE_EMBEDDED,
.JackID = 0x03,
.NumberOfPins = 1,
.SourceJackID = {0x02},
.SourcePinID = {0x01},
.JackStrIndex = NO_DESCRIPTOR
},
.MIDI_Out_Jack_Ext =
{
.Header = {.Size = sizeof(USB_MIDI_Out_Jack_t), .Type = DTYPE_AudioInterface},
.Subtype = DSUBTYPE_OutputJack,
.JackType = JACKTYPE_EXTERNAL,
.JackID = 0x04,
.NumberOfPins = 1,
.SourceJackID = {0x01},
.SourcePinID = {0x01},
.JackStrIndex = NO_DESCRIPTOR
},
.MIDI_In_Jack_Endpoint =
{
.Endpoint =
{
.Header = {.Size = sizeof(USB_Audio_StreamEndpoint_Std_t), .Type = DTYPE_Endpoint},
.EndpointAddress = (ENDPOINT_DESCRIPTOR_DIR_OUT | MIDI_STREAM_OUT_EPNUM),
.Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
.EndpointSize = MIDI_STREAM_EPSIZE,
.PollingIntervalMS = 0
},
.Refresh = 0,
.SyncEndpointNumber = 0
},
.MIDI_In_Jack_Endpoint_SPC =
{
.Header = {.Size = sizeof(USB_MIDI_Jack_Endpoint_t), .Type = DTYPE_AudioEndpoint},
.Subtype = DSUBTYPE_General,
.TotalEmbeddedJacks = 0x01,
.AssociatedJackID = {0x01}
},
.MIDI_Out_Jack_Endpoint =
{
.Endpoint =
{
.Header = {.Size = sizeof(USB_Audio_StreamEndpoint_Std_t), .Type = DTYPE_Endpoint},
.EndpointAddress = (ENDPOINT_DESCRIPTOR_DIR_IN | MIDI_STREAM_IN_EPNUM),
.Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
.EndpointSize = MIDI_STREAM_EPSIZE,
.PollingIntervalMS = 0
},
.Refresh = 0,
.SyncEndpointNumber = 0
},
.MIDI_Out_Jack_Endpoint_SPC =
{
.Header = {.Size = sizeof(USB_MIDI_Jack_Endpoint_t), .Type = DTYPE_AudioEndpoint},
.Subtype = DSUBTYPE_General,
.TotalEmbeddedJacks = 0x01,
.AssociatedJackID = {0x03}
}
};
/** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests
* the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate
* via the language ID table available at USB.org what languages the device supports for its string descriptors.
*/
USB_Descriptor_String_t PROGMEM LanguageString =
{
.Header = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
.UnicodeString = {LANGUAGE_ID_ENG}
};
/** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable
* form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
* Descriptor.
*/
USB_Descriptor_String_t PROGMEM ManufacturerString =
{
.Header = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},
.UnicodeString = L"Dean Camera"
};
/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,
* and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
* Descriptor.
*/
USB_Descriptor_String_t PROGMEM ProductString =
{
.Header = {.Size = USB_STRING_LEN(14), .Type = DTYPE_String},
.UnicodeString = L"LUFA MIDI Demo"
};
/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
* documentation) by the application code so that the address and size of a requested descriptor can be given
* to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
* is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
* USB host.
*/
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, const uint8_t wIndex, void** const DescriptorAddress)
{
const uint8_t DescriptorType = (wValue >> 8);
const uint8_t DescriptorNumber = (wValue & 0xFF);
void* Address = NULL;
uint16_t Size = NO_DESCRIPTOR;
switch (DescriptorType)
{
case DTYPE_Device:
Address = (void*)&DeviceDescriptor;
Size = sizeof(USB_Descriptor_Device_t);
break;
case DTYPE_Configuration:
Address = (void*)&ConfigurationDescriptor;
Size = sizeof(USB_Descriptor_Configuration_t);
break;
case DTYPE_String:
switch (DescriptorNumber)
{
case 0x00:
Address = (void*)&LanguageString;
Size = pgm_read_byte(&LanguageString.Header.Size);
break;
case 0x01:
Address = (void*)&ManufacturerString;
Size = pgm_read_byte(&ManufacturerString.Header.Size);
break;
case 0x02:
Address = (void*)&ProductString;
Size = pgm_read_byte(&ProductString.Header.Size);
break;
}
break;
}
*DescriptorAddress = Address;
return Size;
}
Bootloaders/Incomplete/MIDI/Descriptors.h deleted 100644 → 0
+ 0
− 189
View file @ 59c4871f
/*
LUFA Library
Copyright (C) Dean Camera, 2010.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* Header file for Descriptors.c.
*/
#ifndef _DESCRIPTORS_H_
#define _DESCRIPTORS_H_
/* Includes: */
#include <LUFA/Drivers/USB/USB.h>
#include <avr/pgmspace.h>
/* Macros: */
/** Descriptor header constant to indicate a Audio class interface descriptor. */
#define DTYPE_AudioInterface 0x24
/** Descriptor header constant to indicate a Audio class endpoint descriptor. */
#define DTYPE_AudioEndpoint 0x25
/** Audio class descriptor subtype value for a Audio class specific header descriptor. */
#define DSUBTYPE_Header 0x01
/** Audio class descriptor subtype value for a Audio class specific MIDI input jack descriptor. */
#define DSUBTYPE_InputJack 0x02
/** Audio class descriptor subtype value for a Audio class specific MIDI output jack descriptor. */
#define DSUBTYPE_OutputJack 0x03
/** Audio class descriptor subtype value for a general Audio class specific descriptor. */
#define DSUBTYPE_General 0x01
/** Audio class descriptor jack type value for an embedded (logical) MIDI input or output jack. */
#define JACKTYPE_EMBEDDED 0x01
/** Audio class descriptor jack type value for an external (physical) MIDI input or output jack. */
#define JACKTYPE_EXTERNAL 0x02
/** Endpoint number of the MIDI streaming data OUT endpoint, for host-to-device data transfers. */
#define MIDI_STREAM_OUT_EPNUM 1
/** Endpoint number of the MIDI streaming data IN endpoint, for device-to-host data transfers. */
#define MIDI_STREAM_IN_EPNUM 2
/** Endpoint size in bytes of the Audio isochronous streaming data IN and OUT endpoints. */
#define MIDI_STREAM_EPSIZE 64
/* Type Defines: */
/** Type define for an Audio class specific interface descriptor. This follows a regular interface descriptor to
* supply extra information about the audio device's layout to the host. See the USB Audio specification for more
* details.
*/
typedef struct
{
USB_Descriptor_Header_t Header; /**< Regular descriptor header containing the descriptor's type and length */
uint8_t Subtype; /**< Sub type value used to distinguish between audio class specific descriptors */
uint16_t ACSpecification; /** Binary coded decimal value, indicating the supported Audio Class specification version */
uint16_t TotalLength; /** Total length of the Audio class specific control descriptors, including this descriptor */
uint8_t InCollection; /** Total number of audio class interfaces within this device */
uint8_t InterfaceNumbers[1]; /** Interface numbers of each audio interface */
} USB_Audio_Interface_AC_t;
/** Type define for an Audio class specific MIDI streaming interface descriptor. This indicates to the host
* how MIDI the specification compliance of the device and the total length of the Audio class specific descriptors.
* See the USB Audio specification for more details.
*/
typedef struct
{
USB_Descriptor_Header_t Header; /**< Regular descriptor header containing the descriptor's type and length */
uint8_t Subtype; /**< Sub type value used to distinguish between audio class specific descriptors */
uint16_t AudioSpecification; /**< Binary coded decimal value, indicating the supported Audio Class specification version */
uint16_t TotalLength; /**< Total length of the Audio class specific descriptors, including this descriptor */
} USB_Audio_Interface_MIDI_AS_t;
/** Type define for an Audio class specific endpoint descriptor. This contains a regular endpoint
* descriptor with a few Audio-class specific extensions. See the USB Audio specification for more details.
*/
typedef struct
{
USB_Descriptor_Endpoint_t Endpoint; /**< Standard endpoint descriptor describing the audio endpoint */
uint8_t Refresh; /**< Always set to zero */
uint8_t SyncEndpointNumber; /**< Endpoint address to send synchronization information to, if needed (zero otherwise) */
} USB_Audio_StreamEndpoint_Std_t;
/** Type define for an Audio class specific MIDI IN jack. This gives information to the host on a MIDI input, either
* a physical input jack, or a logical jack (receiving input data internally, or from the host via an endpoint).
*/
typedef struct
{
USB_Descriptor_Header_t Header; /**< Regular descriptor header containing the descriptor's type and length */
uint8_t Subtype; /**< Sub type value used to distinguish between audio class specific descriptors */
uint8_t JackType; /**< Type of jack, one of the JACKTYPE_* mask values */
uint8_t JackID; /**< ID value of this jack - must be a unique value within the device */
uint8_t JackStrIndex; /**< Index of a string descriptor describing this descriptor within the device */
} USB_MIDI_In_Jack_t;
/** Type define for an Audio class specific MIDI OUT jack. This gives information to the host on a MIDI output, either
* a physical output jack, or a logical jack (sending output data internally, or to the host via an endpoint).
*/
typedef struct
{
USB_Descriptor_Header_t Header; /**< Regular descriptor header containing the descriptor's type and length */
uint8_t Subtype; /**< Sub type value used to distinguish between audio class specific descriptors */
uint8_t JackType; /**< Type of jack, one of the JACKTYPE_* mask values */
uint8_t JackID; /**< ID value of this jack - must be a unique value within the device */
uint8_t NumberOfPins; /**< Number of output channels within the jack, either physical or logical */
uint8_t SourceJackID[1]; /**< ID of each output pin's source data jack */
uint8_t SourcePinID[1]; /**< Pin number in the input jack of each output pin's source data */
uint8_t JackStrIndex; /**< Index of a string descriptor describing this descriptor within the device */
} USB_MIDI_Out_Jack_t;
/** Type define for an Audio class specific extended MIDI jack endpoint descriptor. This contains extra information
* on the usage of MIDI endpoints used to stream MIDI events in and out of the USB Audio device, and follows an Audio
* class specific extended MIDI endpoint descriptor. See the USB Audio specification for more details.
*/
typedef struct
{
USB_Descriptor_Header_t Header; /**< Regular descriptor header containing the descriptor's type and length */
uint8_t Subtype; /**< Sub type value used to distinguish between audio class specific descriptors */
uint8_t TotalEmbeddedJacks; /**< Total number of jacks inside this endpoint */
uint8_t AssociatedJackID[1]; /**< IDs of each jack inside the endpoint */
} USB_MIDI_Jack_Endpoint_t;
/** Type define for the device configuration descriptor structure. This must be defined in the
* application code, as the configuration descriptor contains several sub-descriptors which
* vary between devices, and which describe the device's usage to the host.
*/
typedef struct
{
USB_Descriptor_Configuration_Header_t Config;
USB_Descriptor_Interface_t AudioControlInterface;
USB_Audio_Interface_AC_t AudioControlInterface_SPC;
USB_Descriptor_Interface_t AudioStreamInterface;
USB_Audio_Interface_MIDI_AS_t AudioStreamInterface_SPC;
USB_MIDI_In_Jack_t MIDI_In_Jack_Emb;
USB_MIDI_In_Jack_t MIDI_In_Jack_Ext;
USB_MIDI_Out_Jack_t MIDI_Out_Jack_Emb;
USB_MIDI_Out_Jack_t MIDI_Out_Jack_Ext;
USB_Audio_StreamEndpoint_Std_t MIDI_In_Jack_Endpoint;
USB_MIDI_Jack_Endpoint_t MIDI_In_Jack_Endpoint_SPC;
USB_Audio_StreamEndpoint_Std_t MIDI_Out_Jack_Endpoint;
USB_MIDI_Jack_Endpoint_t MIDI_Out_Jack_Endpoint_SPC;
} USB_Descriptor_Configuration_t;
/* Function Prototypes: */
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, const uint8_t wIndex, void** const DescriptorAddress)
ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(3);
#endif
Bootloaders/Incomplete/MIDI/Doxygen.conf deleted 100644 → 0
+ 0
− 1564
View file @ 59c4871f
This diff is collapsed.
Bootloaders/Incomplete/MIDI/JavaHost/BIN2BOOT.java deleted 100644 → 0
+ 0
− 178
View file @ 59c4871f
import javax.sound.midi.*;
import javax.sound.midi.MidiMessage.*;
import java.io.RandomAccessFile;
class BIN2BOOT
{
private static final int MIDI_CONTROL_CHANNEL = 9;
private static final int MIDI_DATA_CHANNEL = 0;
private static final int CONTROL_DEVICE_READY = 0xD1;
private static final int CONTROL_ENTER_PROG_MODE = 0xDC;
private static final int CONTROL_LEAVE_PROG_MODE = 0xDF;
private static final int CONTROL_GET_PAGE_SIZE = 0x01;
public static void main(String[] args)
{
if (args.length != 1)
{
System.out.println("BIN2BOOT - USB-MIDI bootloader");
System.out.println(" Usage: java BIN2BOOT {input}.bin");
}
RandomAccessFile inFile = null;
try
{
inFile = new RandomAccessFile(args[0], "r");
}
catch (Exception e)
{
System.out.println("Could not open input file!");
return;
}
MidiDevice currDevice = null;
Receiver midiOut = null;
Transmitter midiIn = null;
MIDIMessageReceiver midiInMessages = new MIDIMessageReceiver();
try
{
MidiDevice.Info[] infos = MidiSystem.getMidiDeviceInfo();
for (MidiDevice.Info info : infos)
{
currDevice = MidiSystem.getMidiDevice(info);
if (!(currDevice instanceof Sequencer) && !(currDevice instanceof Synthesizer))
{
if (info.getName().indexOf("LUFA") == -1)
continue;
System.out.println(" MIDI Device: " + info.getName());
currDevice.open();
if (currDevice.getMaxReceivers() != 0)
{
midiOut = currDevice.getReceiver();
break;
}
if (currDevice.getMaxTransmitters() != 0)
{
midiIn = currDevice.getTransmitter();
midiIn.setReceiver(midiInMessages);
}
}
}
if ((midiOut == null) || (midiIn == null))
{
System.out.println("Could not find suitable MIDI device!");
return;
}
}
catch (Exception e)
{
System.out.println("Could not enumerate MIDI devices!");
return;
}
System.out.println("PROGRAMMING FILE...");
ProgramFirmware(inFile, midiOut, midiInMessages);
System.out.println("DONE.");
try
{
midiOut.close();
midiIn.close();
currDevice.close();
inFile.close();
}
catch (Exception e)
{
System.out.println("ERROR: Could not close open resources.");
}
}
private static void ProgramFirmware(RandomAccessFile inFile, Receiver midiOut, MIDIMessageReceiver midiInMessages)
{
try
{
System.out.println("Entering Programming Mode...");
sendByteViaMIDI(midiOut, MIDI_CONTROL_CHANNEL, CONTROL_ENTER_PROG_MODE);
int[] messageData;
do
{
messageData = receiveByteViaMIDI(midiInMessages);
}
while ((messageData[0] != MIDI_CONTROL_CHANNEL) && (messageData[1] != CONTROL_DEVICE_READY));
System.out.println("Getting Page Size...");
sendByteViaMIDI(midiOut, MIDI_CONTROL_CHANNEL, CONTROL_GET_PAGE_SIZE);
int nextByte = inFile.read();
while (nextByte != -1)
{
sendByteViaMIDI(midiOut, 9, nextByte);
if ((inFile.getFilePointer() % (inFile.length() / 100)) == 0)
System.out.println(" LOADING: " + (int)(inFile.getFilePointer() / (inFile.length() / 100.0)) + "%...");
nextByte = inFile.read();
}
sendByteViaMIDI(midiOut, MIDI_CONTROL_CHANNEL, CONTROL_LEAVE_PROG_MODE);
}
catch (Exception e)
{
System.out.println("ERROR: Could not send data to device.");
}
}
private static void sendByteViaMIDI(Receiver midiOut, int channel, int data)
{
ShortMessage sendMessage = new ShortMessage();
try
{
sendMessage.setMessage(ShortMessage.NOTE_ON, channel, (data & 0x7F), (((data & 0x80) == 0x80) ? 64 : 32));
midiOut.send(sendMessage, -1);
// try {Thread.sleep(1);} catch (Exception e) {}
sendMessage.setMessage(ShortMessage.NOTE_OFF, channel, (data & 0x7F), (((data & 0x80) == 0x80) ? 64 : 32));
midiOut.send(sendMessage, -1);
}
catch (Exception e)
{
System.out.println("ERROR: Could not send MIDI note press.");
}
}
private static int[] receiveByteViaMIDI(MIDIMessageReceiver midiInReceiver)
{
byte[] messageData;
do
{
while (!(midiInReceiver.hasReceived()));
messageData = midiInReceiver.receive().getMessage();
}
while ((messageData[0] & 0xF0) != ShortMessage.NOTE_ON);
int channel = (messageData[0] & 0x0F);
int data = (messageData[1] | ((messageData[2] == 64) ? 0x80 : 0x00));
int[] formattedMessageData = new int[2];
formattedMessageData[0] = channel;
formattedMessageData[1] = data;
return formattedMessageData;
}
}
\ No newline at end of file
Bootloaders/Incomplete/MIDI/JavaHost/MIDIMessageReceiver.java deleted 100644 → 0
+ 0
− 33
View file @ 59c4871f
import java.util.PriorityQueue;
import javax.sound.midi.*;
import javax.sound.midi.MidiMessage.*;
class MIDIMessageReceiver implements Receiver
{
private PriorityQueue<MidiMessage> messages;
MIDIMessageReceiver()
{
messages = new PriorityQueue<MidiMessage>();
}
public void send(MidiMessage message, long timeStamp)
{
messages.add(message);
}
public boolean hasReceived()
{
return (messages.size() != 0);
}
public MidiMessage receive()
{
return messages.poll();
}
public void close()
{
}
}
Bootloaders/Incomplete/MIDI/MIDI.c deleted 100644 → 0
+ 0
− 132
View file @ 59c4871f
/*
LUFA Library
Copyright (C) Dean Camera, 2010.
dean [at] fourwalledcubicle [dot] com
www.fourwalledcubicle.com
*/
/*
Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness. In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/
/** \file
*
* Main source file for the MIDI bootloader. This file contains the main tasks of the demo and
* is responsible for the initial application hardware configuration.
*/
#include "MIDI.h"
/** Main program entry point. This routine configures the hardware required by the application, then
* enters a loop to run the application tasks in sequence.
*/
int main(void)
{
SetupHardware();
LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
for (;;)
{
MIDI_Task();
USB_USBTask();
}
}
/** Configures the board hardware and chip peripherals for the demo's functionality. */
void SetupHardware(void)
{
/* Disable watchdog if enabled by bootloader/fuses */
MCUSR &= ~(1 << WDRF);
wdt_disable();
/* Disable clock division */
clock_prescale_set(clock_div_1);
/* Hardware Initialization */
LEDs_Init();
USB_Init();
}
/** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs. */
void EVENT_USB_Device_Connect(void)
{
/* Indicate USB enumerating */
LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
}
/** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
* the status LEDs, disables the sample update and PWM output timers and stops the USB and MIDI management tasks.
*/
void EVENT_USB_Device_Disconnect(void)
{
/* Indicate USB not ready */
LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
}
/** Event handler for the USB_ConfigurationChanged event. This is fired when the host set the current configuration
* of the USB device after enumeration - the device endpoints are configured and the MIDI management task started.
*/
void EVENT_USB_Device_ConfigurationChanged(void)
{
/* Indicate USB connected and ready */
LEDs_SetAllLEDs(LEDMASK_USB_READY);
/* Setup MIDI stream endpoints */
if (!(Endpoint_ConfigureEndpoint(MIDI_STREAM_OUT_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_OUT, MIDI_STREAM_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
if (!(Endpoint_ConfigureEndpoint(MIDI_STREAM_IN_EPNUM, EP_TYPE_BULK,
ENDPOINT_DIR_IN, MIDI_STREAM_EPSIZE,
ENDPOINT_BANK_SINGLE)))
{
LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
}
}
/** Task to handle the generation of MIDI note change events in response to presses of the board joystick, and send them
* to the host.
*/
void MIDI_Task(void)
{
/* Device must be connected and configured for the task to run */
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
/* Select the MIDI OUT stream */
Endpoint_SelectEndpoint(MIDI_STREAM_OUT_EPNUM);
if (Endpoint_IsOUTReceived())
{
USB_MIDI_EventPacket_t Packet;
Endpoint_Read_Stream_LE(&Packet, sizeof(Packet));
LEDs_SetAllLEDs(Packet.Data2 > 64 ? LEDS_LED1 : LEDS_LED2);
Endpoint_ClearOUT();
}
}
Bootloaders/Incomplete/MIDI/makefile deleted 100644 → 0
+ 0
− 704
View file @ 59c4871f
This diff is collapsed.
LUFA.pnproj
+ 1
− 1
View file @ 1090e767
This diff is collapsed.
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please to comment