/elec/audio-switcher

To get this branch, use:
bzr branch http://bzr.ed.am/elec/audio-switcher

« back to all changes in this revision

Viewing changes to src/VirtualSerial.c

  • Committer: Tim Marston
  • Date: 2012-11-22 18:45:43 UTC
  • Revision ID: tim@ed.am-20121122184543-ysse46aabr0akflw
wrote README and renamed NOTES

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VirtualSerial.c
1
1
/*
2
 
 
3
 
  AUDIO SWITCHER
4
 
 
5
 
  Based on a serial device demonstration from the LUFA project
6
 
  (www.lufa-lib.org).  LUFA is Copyright (C) Dean Camera, 2012.
7
 
 
8
 
  Changes made to the serial device demonstration program are
9
 
  Copyright (C) Tim Marston, 2012.
10
 
 
11
 
  For more information:
12
 
    * see README, or
13
 
    * visit http://ed.am/
14
 
 
 
2
             LUFA Library
 
3
     Copyright (C) Dean Camera, 2012.
 
4
 
 
5
  dean [at] fourwalledcubicle [dot] com
 
6
           www.lufa-lib.org
15
7
*/
16
8
 
17
9
/*
38
30
 
39
31
/** \file
40
32
 *
41
 
 *  Main source file for the VirtualSerial demo. This file contains the main
42
 
 *  tasks of the demo and is responsible for the initial application hardware
43
 
 *  configuration.
 
33
 *  Main source file for the VirtualSerial demo. This file contains the main tasks of
 
34
 *  the demo and is responsible for the initial application hardware configuration.
44
35
 */
45
36
 
46
37
#include "VirtualSerial.h"
47
 
#include "wiring.h"
48
38
 
49
 
/** LUFA CDC Class driver interface configuration and state information. This
50
 
 *  structure is passed to all CDC Class driver functions, so that multiple
51
 
 *  instances of the same class within a device can be differentiated from one
52
 
 *  another.
 
39
/** LUFA CDC Class driver interface configuration and state information. This structure is
 
40
 *  passed to all CDC Class driver functions, so that multiple instances of the same class
 
41
 *  within a device can be differentiated from one another.
53
42
 */
54
43
USB_ClassInfo_CDC_Device_t VirtualSerial_CDC_Interface =
55
44
        {
77
66
                        },
78
67
        };
79
68
 
80
 
/** Standard file stream for the CDC interface when set up, so that the virtual
81
 
 *  CDC COM port can be used like any regular character stream in the C APIs
 
69
/** Standard file stream for the CDC interface when set up, so that the virtual CDC COM port can be
 
70
 *  used like any regular character stream in the C APIs
82
71
 */
83
72
static FILE USBSerialStream;
84
73
 
85
74
 
86
75
#define BUTTON 0b10000000
87
76
#define LEDB 0b00100000
88
 
#define RELAY 0b00000010
89
77
 
90
78
void init()
91
79
{
92
 
        // set PD7 (button) to input and enable pull-up
 
80
        // set PD7 (button) to input
93
81
        DDRD &= ~BUTTON;
 
82
 
 
83
        // enable pull-up on PD7 (button)
94
84
        PORTD |= BUTTON;
95
85
 
96
86
        // set PD5 (ledb) to output
97
87
        DDRD |= LEDB;
98
 
 
99
 
        // set PB1 (relay) to output
100
 
        DDRB |= RELAY;
101
88
}
102
89
 
103
 
#define BUFFERLEN 10
104
 
 
105
90
void loop()
106
91
{
107
 
        // debounce button (PD7)
108
 
        static int button_state = 0;
109
 
        static int saved_button_state = 0;
110
 
        static int saved_since = 0;
111
 
        unsigned long now = millis();
112
 
        unsigned long real_button_state = PIND & BUTTON;
113
 
        bool button_state_changed = false;
114
 
        if( saved_button_state != real_button_state ) {
115
 
                saved_button_state = real_button_state;
116
 
                saved_since = now;
117
 
        }
118
 
        else if( saved_button_state != button_state &&
119
 
                         now - saved_since > 25 )
120
 
        {
121
 
                button_state = saved_button_state;
122
 
                button_state_changed = true;
123
 
        }
124
 
 
125
 
        // read buffer from serial
126
 
        static int buffer_pos = 0;
127
 
        static char buffer[ BUFFERLEN ] = "";
128
 
        int got = getc( &USBSerialStream );
129
 
        bool got_command = false;
130
 
        switch( got ) {
131
 
        case EOF:
132
 
        case 0: break;
133
 
        case '\r': 
134
 
        case '\n': got_command = true; break;
135
 
        case ' ':
136
 
        case '\t':
137
 
                if( !buffer_pos ) break;
138
 
                // fall through
139
 
        default:
140
 
                if( buffer_pos < ( BUFFERLEN - 1 ) )
141
 
                        buffer[ buffer_pos++ ] = got;
142
 
                buffer[ buffer_pos ] = 0;
143
 
        }
144
 
 
145
 
        static bool relay_state = false;
146
 
        bool toggle_relay = false;
147
 
 
148
 
        // handle command
149
 
        if( got_command )
150
 
        {
151
 
                // command: turn relay off
152
 
                if( !strcmp( buffer, "0" ) ) {
153
 
                        if( relay_state ) toggle_relay = true;
154
 
                }
155
 
 
156
 
                // command: turn relay on
157
 
                else if( !strcmp( buffer, "1" ) ) {
158
 
                        if( !relay_state ) toggle_relay = true;
159
 
                }
160
 
 
161
 
                // command: report relay state
162
 
                else if( !strcmp( buffer, "?" ) ) {
163
 
                        fputs( relay_state? "1\r\n" : "0\r\n", &USBSerialStream );
164
 
                }
165
 
 
166
 
                // command: toggle relay state
167
 
                else if( !strcmp( buffer, "." ) ) {
168
 
                        toggle_relay = true;
169
 
                }
170
 
 
171
 
                // clear command
172
 
                buffer_pos = buffer[ 0 ] = 0;
173
 
        }
174
 
 
175
 
        // handle button press?
176
 
        if( button_state_changed && !button_state )
177
 
        {
178
 
                toggle_relay = true;
179
 
        }
180
 
 
181
 
        // toggle the relay?
182
 
        if( toggle_relay )
183
 
        {
184
 
                relay_state = !relay_state;
185
 
 
186
 
                // switch relay
187
 
                if( relay_state )
188
 
                        PORTB |= RELAY;
189
 
                else
190
 
                        PORTB &= ~RELAY;
191
 
 
192
 
                // switch LED
193
 
                if( relay_state )
194
 
                        PORTD &= ~LEDB;
195
 
                else
196
 
                        PORTD |= LEDB;
 
92
        static bool sent = false;
 
93
 
 
94
        // if PD7 is low, we have a press!
 
95
        if( PIND & BUTTON )
 
96
        {
 
97
                if( !sent )
 
98
                {
 
99
                        sent = true;
 
100
                        fputs( "press\r\n", &USBSerialStream );
 
101
                }
 
102
 
 
103
                // set led
 
104
                PORTD |= LEDB;
 
105
        }
 
106
        else
 
107
        {
 
108
                sent = false;
 
109
 
 
110
                // set led
 
111
                PORTD &= ~LEDB;
197
112
        }
198
113
}
199
114
 
200
115
 
201
 
/** Main program entry point. This routine contains the overall program flow,
202
 
 *  including initial setup of all components and the main program loop.
 
116
/** Main program entry point. This routine contains the overall program flow, including initial
 
117
 *  setup of all components and the main program loop.
203
118
 */
204
119
int main(void)
205
120
{
206
121
        SetupHardware();
207
122
 
208
 
        /* Create a regular character stream for the interface so that it can be
209
 
         * used with the stdio.h functions */
 
123
        /* Create a regular character stream for the interface so that it can be used with the stdio.h functions */
210
124
        CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream);
211
125
 
212
126
        LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
216
130
        {
217
131
                loop();
218
132
 
 
133
                /* Must throw away unused bytes from the host, or it will lock up while waiting for the device */
 
134
                CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);
 
135
 
219
136
                CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
220
137
                USB_USBTask();
221
138
        }
222
139
}
223
140
 
224
 
/** Configures the board hardware and chip peripherals for the demo's
225
 
 * functionality. */
 
141
/** Configures the board hardware and chip peripherals for the demo's functionality. */
226
142
void SetupHardware(void)
227
143
{
228
144
        /* Disable watchdog if enabled by bootloader/fuses */
236
152
        LEDs_Init();
237
153
        USB_Init();
238
154
 
239
 
        // my init
240
 
        init();
241
 
 
242
 
        // set up arduino wiring.c
243
 
        init_wiring_c();
244
 
}
 
155
        init(); 
 
156
}
 
157
 
 
158
/** Checks for changes in the position of the board joystick, sending strings to the host upon each change. */
 
159
#if 0
 
160
void CheckJoystickMovement(void)
 
161
{
 
162
        uint8_t     JoyStatus_LCL = Joystick_GetStatus();
 
163
        char*       ReportString  = NULL;
 
164
        static bool ActionSent    = false;
 
165
 
 
166
        if (JoyStatus_LCL & JOY_UP)
 
167
          ReportString = "Joystick Up\r\n";
 
168
        else if (JoyStatus_LCL & JOY_DOWN)
 
169
          ReportString = "Joystick Down\r\n";
 
170
        else if (JoyStatus_LCL & JOY_LEFT)
 
171
          ReportString = "Joystick Left\r\n";
 
172
        else if (JoyStatus_LCL & JOY_RIGHT)
 
173
          ReportString = "Joystick Right\r\n";
 
174
        else if (JoyStatus_LCL & JOY_PRESS)
 
175
          ReportString = "Joystick Pressed\r\n";
 
176
        else
 
177
          ActionSent = false;
 
178
 
 
179
        if ((ReportString != NULL) && (ActionSent == false))
 
180
        {
 
181
                ActionSent = true;
 
182
 
 
183
                /* Write the string to the virtual COM port via the created character stream */
 
184
                fputs(ReportString, &USBSerialStream);
 
185
 
 
186
                /* Alternatively, without the stream: */
 
187
                // CDC_Device_SendString(&VirtualSerial_CDC_Interface, ReportString);
 
188
        }
 
189
}
 
190
#endif
245
191
 
246
192
/** Event handler for the library USB Connection event. */
247
193
void EVENT_USB_Device_Connect(void)