1 /*
2 * Author: Jon Trulson <jtrulson@ics.com>
3 * Copyright (c) 2015 Intel Corporation.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be
14 * included in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 #include <iostream>
26
27 #include "rgbringcoder.h"
28
29 using namespace std;
30 using namespace upm;
31
RGBRingCoder(int en,int latch,int clear,int clk,int dat,int sw,int encA,int encB,int red,int green,int blue)32 RGBRingCoder::RGBRingCoder(int en, int latch, int clear, int clk, int dat,
33 int sw, int encA, int encB, int red,
34 int green, int blue) :
35 m_gpioEn(en), m_gpioLatch(latch), m_gpioClear(clear), m_gpioClock(clk),
36 m_gpioData(dat), m_gpioSwitch(sw), m_gpioEncA(encA), m_gpioEncB(encB),
37 m_pwmRed(red), m_pwmGreen(green), m_pwmBlue(blue)
38 {
39 m_counter = 0;
40
41 // enable, set LOW
42 m_gpioEn.dir(mraa::DIR_OUT);
43 m_gpioEn.write(0);
44
45 // latch
46 m_gpioLatch.dir(mraa::DIR_OUT);
47 m_gpioLatch.write(0);
48
49 // clear, HIGH
50 m_gpioClear.dir(mraa::DIR_OUT);
51 m_gpioLatch.write(1);
52
53 // clock
54 m_gpioClock.dir(mraa::DIR_OUT);
55 m_gpioClock.write(0);
56
57 // data
58 m_gpioData.dir(mraa::DIR_OUT);
59 m_gpioData.write(0);
60
61 // switch
62 m_gpioSwitch.dir(mraa::DIR_IN);
63 m_gpioSwitch.mode(mraa::MODE_HIZ); // no pullup
64 m_gpioSwitch.write(0);
65
66 // ecoder A interrupt
67 m_gpioEncA.dir(mraa::DIR_IN);
68 m_gpioEncA.mode(mraa::MODE_PULLUP);
69 // EDGE_BOTH would be nice...
70 m_gpioEncA.isr(mraa::EDGE_RISING, &interruptHandler, this);
71
72 // ecoder B interrupt
73 m_gpioEncB.dir(mraa::DIR_IN);
74 m_gpioEncB.mode(mraa::MODE_PULLUP);
75 // EDGE_BOTH would be nice...
76 m_gpioEncB.isr(mraa::EDGE_RISING, &interruptHandler, this);
77
78 // RGB LED pwms, set to off
79
80 // Red led
81 m_pwmRed.period_ms(1);
82 m_pwmRed.write(0.99);
83 m_pwmRed.enable(true);
84
85 // Green led
86 m_pwmGreen.period_ms(1);
87 m_pwmGreen.write(0.99);
88 m_pwmGreen.enable(true);
89
90 // Blue led
91 m_pwmBlue.period_ms(1);
92 m_pwmBlue.write(0.99);
93 m_pwmBlue.enable(true);
94
95 // whew.
96 }
97
~RGBRingCoder()98 RGBRingCoder::~RGBRingCoder()
99 {
100 m_gpioEncA.isrExit();
101 m_gpioEncB.isrExit();
102
103 // turn off the ring
104 setRingLEDS(0x0000);
105
106 // Turn of RGB LEDS
107 setRGBLED(0.99, 0.99, 0.99);
108 usleep(100000);
109
110 // turn off PWM's
111 m_pwmRed.enable(false);
112 m_pwmGreen.enable(false);
113 m_pwmBlue.enable(false);
114 }
115
interruptHandler(void * ctx)116 void RGBRingCoder::interruptHandler(void *ctx)
117 {
118 upm::RGBRingCoder *This = (upm::RGBRingCoder *)ctx;
119
120 // From the Sparkfun guys:
121
122 // enc_states[] is a fancy way to keep track of which direction
123 // the encoder is turning. 2-bits of oldEncoderState are paired
124 // with 2-bits of newEncoderState to create 16 possible values.
125 // Each of the 16 values will produce either a CW turn (1),
126 // CCW turn (-1) or no movement (0).
127
128 static int8_t enc_states[] = {0, -1, 1, 0, 1, 0, 0, -1,
129 -1, 0, 0, 1, 0, 1, -1, 0};
130 static uint8_t oldEncoderState = 0;
131 static uint8_t newEncoderState = 0;
132
133 // First, find the newEncoderState. This'll be a 2-bit value
134 // the msb is the state of the B pin. The lsb is the state
135 // of the A pin on the encoder.
136 newEncoderState = (This->m_gpioEncB.read()<<1) |
137 (This->m_gpioEncA.read());
138
139 // Now we pair oldEncoderState with new encoder state
140 // First we need to shift oldEncoder state left two bits.
141 // This'll put the last state in bits 2 and 3.
142
143 oldEncoderState <<= 2;
144
145 // Mask out everything in oldEncoderState except for the previous state
146 oldEncoderState &= 0x0c;
147
148 // Now add the newEncoderState. oldEncoderState will now be of
149 // the form: 0b0000(old B)(old A)(new B)(new A)
150 oldEncoderState |= newEncoderState;
151
152 // update our counter
153 This->m_counter += enc_states[oldEncoderState & 0x0f];
154 }
155
setRingLEDS(uint16_t bits)156 void RGBRingCoder::setRingLEDS(uint16_t bits)
157 {
158 // First we need to set latch LOW
159 m_gpioLatch.write(0);
160
161 // Now shift out the bits, msb first
162 for (int i=0; i<16; i++)
163 {
164 m_gpioData.write( ((bits & 0x8000) ? 1 : 0) );
165
166 // pulse the clock pin
167 m_gpioClock.write(1);
168 m_gpioClock.write(0);
169
170 bits <<= 1;
171 }
172
173 // latch it
174 m_gpioLatch.write(1);
175 }
176
getButtonState()177 bool RGBRingCoder::getButtonState()
178 {
179 return (m_gpioSwitch.read() ? true : false);
180 }
181
setRGBLED(float r,float g,float b)182 void RGBRingCoder::setRGBLED(float r, float g, float b)
183 {
184 m_pwmRed.write(r);
185 m_pwmGreen.write(g);
186 m_pwmBlue.write(b);
187 }
188