/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-23 15:44:20 UTC
  • Revision ID: tim@ed.am-20121123154420-pk5kxho2vbowu69h
added serial buffer reading, command handling and rewrote button press
detection

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VirtualSerial.c
1
1
/*
2
 
             LUFA Library
3
 
     Copyright (C) Dean Camera, 2012.
4
 
 
5
 
  dean [at] fourwalledcubicle [dot] com
6
 
           www.lufa-lib.org
 
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
 
7
15
*/
8
16
 
9
17
/*
30
38
 
31
39
/** \file
32
40
 *
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.
 
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.
35
44
 */
36
45
 
37
46
#include "VirtualSerial.h"
 
47
#include "wiring.h"
38
48
 
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.
 
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.
42
53
 */
43
54
USB_ClassInfo_CDC_Device_t VirtualSerial_CDC_Interface =
44
55
        {
66
77
                        },
67
78
        };
68
79
 
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
 
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
71
82
 */
72
83
static FILE USBSerialStream;
73
84
 
74
85
 
75
86
#define BUTTON 0b10000000
76
87
#define LEDB 0b00100000
 
88
#define RELAY 0b00000010
77
89
 
78
90
void init()
79
91
{
80
 
        // set PD7 (button) to input
 
92
        // set PD7 (button) to input and enable pull-up
81
93
        DDRD &= ~BUTTON;
82
 
 
83
 
        // enable pull-up on PD7 (button)
84
94
        PORTD |= BUTTON;
85
95
 
86
96
        // set PD5 (ledb) to output
87
97
        DDRD |= LEDB;
 
98
 
 
99
        // set PB1 (relay) to output
 
100
        DDRB |= RELAY;
88
101
}
89
102
 
 
103
#define BUFFERLEN 10
 
104
 
90
105
void loop()
91
106
{
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;
 
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;
112
197
        }
113
198
}
114
199
 
115
200
 
116
 
/** Main program entry point. This routine contains the overall program flow, including initial
117
 
 *  setup of all components and the main program loop.
 
201
/** Main program entry point. This routine contains the overall program flow,
 
202
 *  including initial setup of all components and the main program loop.
118
203
 */
119
204
int main(void)
120
205
{
121
206
        SetupHardware();
122
207
 
123
 
        /* Create a regular character stream for the interface so that it can be used with the stdio.h functions */
 
208
        /* Create a regular character stream for the interface so that it can be
 
209
         * used with the stdio.h functions */
124
210
        CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream);
125
211
 
126
212
        LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
130
216
        {
131
217
                loop();
132
218
 
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
 
 
136
219
                CDC_Device_USBTask(&VirtualSerial_CDC_Interface);
137
220
                USB_USBTask();
138
221
        }
139
222
}
140
223
 
141
 
/** Configures the board hardware and chip peripherals for the demo's functionality. */
 
224
/** Configures the board hardware and chip peripherals for the demo's
 
225
 * functionality. */
142
226
void SetupHardware(void)
143
227
{
144
228
        /* Disable watchdog if enabled by bootloader/fuses */
152
236
        LEDs_Init();
153
237
        USB_Init();
154
238
 
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
 
239
        // my init
 
240
        init();
 
241
 
 
242
        // set up arduino wiring.c
 
243
        init_wiring_c();
 
244
}
191
245
 
192
246
/** Event handler for the library USB Connection event. */
193
247
void EVENT_USB_Device_Connect(void)