Announcement

Collapse
No announcement yet.

Need Alpine wired remote control pinout.

Collapse
X
  • Filter
  • Time
  • Show
Clear All
new posts

  • Need Alpine wired remote control pinout.

    EDIT: Figured it out! Scroll down to Post #9.

    Alpine head unit seems to have a standard 3.5mm stereo jack for wired remote input (i.e. steering wheel controls), but for the life of me I can't find a pinout or other instructions anywhere for how to control it. Alpine says to buy a 3rd party adapter, but I was hoping to create my own controller.

    I've found the Pioneer/Sony resistor values and connection scheme, but simply connecting resistances across the pins seems to do nothing on the Alpine.

    Anybody have information on this? I'm coming up completely dry. Many thanks!
    2008 Subaru WRX Worklog

    Music I've created: JackPryorMusic.com

  • #2
    Interesting... The sleeve is ground, I measure about 0.1V on the tip, but the ring reads 5VDC and 10VAC, so it's cycling between 0V and 10V. That doesn't tell me much, except that this would be more complicated to reverse-engineer than I'd hoped...
    2008 Subaru WRX Worklog

    Music I've created: JackPryorMusic.com

    Comment


    • #3
      Oooookay... Seems like every time I search really hard and come up dry, nobody else knows the answer either. So I got it the hard way...

      Dusted off my oscilloscope and was able to crack it. Much more complicated than resistors, unfortunately - needs a microcontroller to send a particular digital code. I'll post a full writeup later. For now I'm going to bed happy.

      (The AC voltage I was detecting above seems to just be noise, or maybe an error with my meter. That had nothing to do with it.)
      2008 Subaru WRX Worklog

      Music I've created: JackPryorMusic.com

      Comment


      • #4
        I'm trying to track down the same info but for Kenwood. From my initial searching, you are the ONLY other person trying to do the same as me.

        I'm using the SWI-JACK from PAC Audio but I can't stand the 1/2 second delay and the VERY high output rate of the Volume control when held down. I don't like my volume going from 0 to 30 in the blink of an eye after an annoying delay, giving me 0 real volume control.

        I've determined that the delay is the SWI's conversion of the input vs the Kenwood's response to the SWI output. The SWI output is what is delayed... not really sure why when an ADC conversion and a few other operations is all that's really needed.

        To answer your question about the AC/DC readings of the signal, here's the deal:

        If you have a square wave with 12V amplitude at a 50% duty cycle (on 50% of it's total cycle) you will read 6V DC with a multimeter, due to the fact that DC is just the average voltage over time.

        A digital signal will be a square wave, on some time, off the rest, which will give a (likely) changing DC value as the digital signal changes.

        You'll also get some AC component since a periodic digital signal (a square wave) is really just the combination of a bunch of sine waves at different harmonics (higher frequencies)

        See this page to see how multiple sine waves gets you closer and closer to a square wave:

        http://www.allaboutcircuits.com/vol_2/chpt_7/2.html

        AND: Your digital signal may be something like I2C, SPI, or just a PWM controlled signal. Good luck reverse engineering.

        I wish the mfr's would just release those interface specs.

        Comment


        • #5
          Thanks for your thoughts. I'm actually done and have a working hack!! Just haven't had time to write it up yet.

          The 5V was a total red herring. The controller works without it even connected, and it's really just a noisy 5V. No usable AC or digital signal at all. Thought it might be a power supply but it can hardly source any current, so I'm not sure.

          Anyway, turns out it's very simple - the controller just sends a one-way series of +5V pulses over the tip conductor. (The one that measured about .1V) I was able to do the same with a PIC controller and it works perfectly!

          About the repeat rate, at least on Alpine... I thought there was a delay in the controller as well, but it turns out that it's actually in the head unit. As soon as a button is depressed, the controller immediately begins sending a continuous stream of the digital signals (even for commands like "Mute" or "Power") and it's the head unit that decides whether it's supposed to go one increment or many, and after what delay. And for a single increment it seems like it waits for you to release the button before it even acknowledges the single press. But again, that's the Alpine head unit's logic - not the controller's.

          When I programmed the PIC to send it just a single command non-repeated, the stereo responded immediately with no noticeable lag. When I programmed the PIC to send continuous messages, it behaved just like the off-the-shelf controller, with the annoying lag and super-fast repeat rate.

          I think the thing to do is to program in my own initial delay - so it sends a single message immediately upon button press, then if it's held longer it starts sending the continuous stream of messages.

          Also, since my car only has 6 steering wheel buttons but the Alpine recognizes 10 or so commands, I might program my controller to send a different message for buttons like Mute or Mode depending on if they're pressed quickly or held down. Could be fun to get some extra functionality.

          Well, stay tuned for the full writeup, but hopefully that's some food for thought.
          2008 Subaru WRX Worklog

          Music I've created: JackPryorMusic.com

          Comment


          • #6
            i have been browsing for this info for my alpine stereo and steering wheel controls for ages. FordNoMore did you end up finding what number of pulses, period and frequency it is for each command. as in how many pulses need to be sent for the next, vol+, vol- etc commands.
            also if you could upload your PIC code that would be helpful. i will probably end up using an atmel as i have had more experience with them but code examples always help.

            Comment


            • #7
              Yes I did! Rest assured you can do it with a simple PIC circuit - mine is installed and working great. I just need to find time to write it all up... I'll try to do so this week.
              2008 Subaru WRX Worklog

              Music I've created: JackPryorMusic.com

              Comment


              • #8
                Originally posted by FordNoMore View Post
                Yes I did! Rest assured you can do it with a simple PIC circuit - mine is installed and working great. I just need to find time to write it all up... I'll try to do so this week.

                I am very interested in the circuit, you could hang up the schedules and procedures? thank you very much

                Comment


                • #9
                  Okay, I'll give you the Alpine codes, but first you have to buy my album at www.JackPryorMusic.com. Just kidding... but do check it out! You might like it. (It's part of the reason I've taken so long to write this up... sorry about that.)

                  To control an Alpine stereo remotely, you'll need to program a microcontroller to send it digital commands. It's not a simple resistor ladder as with many other stereos. I used a PIC 18F2550 for this project (just because I had one already) with a 5VDC power supply, and put a 5.6k ohm resistor in series from an I/O pin of the controller to the Alpine unit. It probably would work without the resistor, but it should help protect things in case of a fault.

                  We will be sending purely 1-way signals. There's no handshaking, no acknowledge, no clock... it's just a timed bit stream that repeats as long as a control button is held down.

                  You'll connect to what looks like a stereo jack input on the Alpine head unit as shown here:



                  So, our controller circuit will output through a 1/8" headphone-type jack with connections as shown:



                  Tie the ground to the sleeve and send signals on the tip. Ring doesn't seem to do anything. I left it completely disconnected and it seems to function normally.

                  Each command begins with an 8ms pulse at +5V and then 4.5ms at 0V. Then, a series of 1's and 0's follows. Here is the start of a command as seen on an oscilloscope:



                  What I'm calling a 1 is a +5V signal for 500us (500 microseconds = 0.5 milliseconds) then 0V (ground) for 500 us. What I'm calling a 0 stays at 0V for the full 1000us. There may be another convention for how to describe the signal, but this makes sense to me. Interestingly, there are never two 0's in a row, so there's never longer than 1.5ms at 0V before the next pulse in a command.

                  Here's a detail of the 1's and 0's of a command:



                  As I mentioned, each command repeats as long as the button is held (even one-shot commands like Power or Mute) so after the very last 1, there is about a 41ms delay before it repeats, as you can see here:



                  I don't know how precise the timing needs to be. If you have access to an oscilloscope, that will definitely help with debugging your code to get the timing right. I programmed in C so it took some trial-and-error to get the timing just right.

                  Now, here are all the commands that the off-the-shelf units support. Not sure if there are other codes that would do other fun things. (Experiment at your own risk.)


                  Vol Up 110101111101101110101011110110111101011011010101
                  Vol Dn 110101111101101110101011011011011111011011010101
                  Mute 110101111101101110101011101011011110111011010101
                  Pst up 110101111101101110101011101010111110111101010101
                  Pst dn 110101111101101110101011010101011111111101010101
                  Source 110101111101101110101011101101111101101101010101
                  Trk up 110101111101101110101011101110111101101011010101
                  Trk dn 110101111101101110101011010111011111101011010101
                  Power 110101111101101110101011011101111110101101010101
                  Ent/Play 110101111101101110101011010101111111110101010101
                  Band/prog 110101111101101110101011011010111111011101010101


                  Note that the same series of 1's and 0's is at the start and end of each command, so here are the unique parts of each:


                  (Start) 110101111101101110101011

                  Vol Up 11011011110101101
                  Vol Dn 01101101111101101
                  Mute 10101101111011101
                  Pst up 10101011111011110
                  Pst dn 01010101111111110
                  Source 10110111110110110
                  Trk up 10111011110110101
                  Trk dn 01011101111110101
                  Power 01110111111010110
                  Ent/Play 01010111111111010
                  Band/prog 01101011111101110

                  (End) 1010101


                  That should be all you need to get going. Here was my final circuit:



                  You may notice the yellow Parking Brake and Brake Pedal detection wires leading into my circuit too... No comment.

                  One additional idea: My steering wheel only has one set of "up" and "down" buttons, so it doesn't support both "Preset" and "Track" up/down commands very well. Instead, I programmed my controller so that holding the Mute button toggles it between sending "Preset" commands and "Track" commands from the up and down buttons. (A quick press of Mute just sends a Mute command like normal.) This has worked very well for me since Preset and Track commands are both useful in different modes.

                  There's a little more info about detecting steering wheel button input in my other posting about my Subaru WRX here.

                  Unfortunately this is an advanced electronics project requiring the use of a microcontroller and some reverse-engineering of your own steering wheel controls, but if you're up to the task you can save some money and make a system that does things the off-the-shelf ones don't. (Or for that matter, you could do entirely wild things like have your computer control the stereo volume, or tap the brake pedal twice to mute the stereo... I know how us Car PC people are!)

                  I find it hard to believe that this seems to be the first time anyone's reverse-engineered the Alpine interface and posted about it. It's hard to be original these days (same goes for writing music!) but I'm glad I could contribute something valuable after gleaning such great info from this site.

                  Good luck!
                  2008 Subaru WRX Worklog

                  Music I've created: JackPryorMusic.com

                  Comment


                  • #10
                    So I've searched everywhere on the internet for information about the alpine wired remote interface. Your post is the only thing I've found which is both technical and detailed.

                    My only question is how did you figure out the bit sequence the off-the-shelf units support?

                    Thanks for the great post.

                    Comment


                    • #11
                      Wow thank you so much for that information!

                      Any chance you would share your source code?

                      Comment


                      • #12
                        FordNoMore thanks heaps for the alpine codes and the guide.

                        i ended up programing an arduino to take the input signal from my commodore steering wheel buttons and sending them through to the alpine head unit. it all works a charm but there are a few commands that i wish i knew the alpine codes for.

                        at the moment all the buttons do what they say but a double press on mode is source on the alpine.

                        i will attach my arduino code soon.

                        Comment


                        • #13
                          Originally posted by JC_JC View Post
                          FordNoMore thanks heaps for the alpine codes and the guide.

                          i ended up programing an arduino to take the input signal from my commodore steering wheel buttons and sending them through to the alpine head unit. it all works a charm but there are a few commands that i wish i knew the alpine codes for.

                          at the moment all the buttons do what they say but a double press on mode is source on the alpine.

                          i will attach my arduino code soon.
                          I would love to see your code and how you got this to work.

                          Comment


                          • #14
                            //please excuse the lack of comments
                            // this works with a simgle button and has the correct timings
                            // adding the send of signals to stereo.. simulating by sending to serial
                            #define CHECK_MS 5
                            #define DOUBLE_MS 400
                            #define HOLD_MS 1200

                            #define NO_B 839 //nothing pressed
                            #define MODE_B 662 // MODE
                            #define NXTU_B 509 // NEXT UP
                            #define NXTD_B 380 // NEXT DOWN
                            #define MUTE_B 273 // MUTE
                            #define VOLU_B 180 // VOLUME UP
                            #define VOLD_B 105 // VOLUME DOWN

                            #define alpPin 7

                            boolean volUp[48] = {1,1,0,1,0,1,1,1, 1,1,0,1,1,0,1,1, 1,0,1,0,1,0,1,1, 1,1,0,1,1,0,1,1, 1,1,0,1,0,1,1,0, 1,1,0,1,0,1,0,1};
                            boolean volDn[48] = {1,1,0,1,0,1,1,1, 1,1,0,1,1,0,1,1, 1,0,1,0,1,0,1,1, 0,1,1,0,1,1,0,1, 1,1,1,1,0,1,1,0, 1,1,0,1,0,1,0,1};
                            boolean mute[48] = {1,1,0,1,0,1,1,1, 1,1,0,1,1,0,1,1, 1,0,1,0,1,0,1,1, 1,0,1,0,1,1,0,1, 1,1,1,0,1,1,1,0, 1,1,0,1,0,1,0,1};
                            boolean pstUp[48] = {1,1,0,1,0,1,1,1, 1,1,0,1,1,0,1,1, 1,0,1,0,1,0,1,1, 1,0,1,0,1,0,1,1, 1,1,1,0,1,1,1,1, 0,1,0,1,0,1,0,1};
                            boolean pstDn[48] = {1,1,0,1,0,1,1,1, 1,1,0,1,1,0,1,1, 1,0,1,0,1,0,1,1, 0,1,0,1,0,1,0,1, 1,1,1,1,1,1,1,1, 0,1,0,1,0,1,0,1};
                            boolean source[48] = {1,1,0,1,0,1,1,1, 1,1,0,1,1,0,1,1, 1,0,1,0,1,0,1,1, 1,0,1,1,0,1,1,1, 1,1,0,1,1,0,1,1, 0,1,0,1,0,1,0,1};
                            boolean trkUp[48] = {1,1,0,1,0,1,1,1, 1,1,0,1,1,0,1,1, 1,0,1,0,1,0,1,1, 1,0,1,1,1,0,1,1, 1,1,0,1,1,0,1,0, 1,1,0,1,0,1,0,1};
                            boolean trkDn[48] = {1,1,0,1,0,1,1,1, 1,1,0,1,1,0,1,1, 1,0,1,0,1,0,1,1, 0,1,0,1,1,1,0,1, 1,1,1,1,1,0,1,0, 1,1,0,1,0,1,0,1};
                            boolean power[48] = {1,1,0,1,0,1,1,1, 1,1,0,1,1,0,1,1, 1,0,1,0,1,0,1,1, 0,1,1,1,0,1,1,1, 1,1,1,0,1,0,1,1, 0,1,0,1,0,1,0,1};
                            boolean entPlay[48] = {1,1,0,1,0,1,1,1, 1,1,0,1,1,0,1,1, 1,0,1,0,1,0,1,1, 0,1,0,1,0,1,1,1, 1,1,1,1,1,1,0,1, 0,1,0,1,0,1,0,1};
                            boolean bandProg[48] = {1,1,0,1,0,1,1,1, 1,1,0,1,1,0,1,1, 1,0,1,0,1,0,1,1, 0,1,1,0,1,0,1,1, 1,1,1,1,0,1,1,1, 0,1,0,1,0,1,0,1};

                            boolean spFlag = 0;
                            boolean dpFlag = 0;
                            boolean hpFlag = 0;

                            int button = 0;
                            int spbutton = 0;
                            /*
                            0-none
                            1-mode
                            2-track +
                            3-track -
                            4-mute
                            5-vol+
                            6-vol-
                            */

                            void setup() {
                            Serial.begin(9600);
                            pinMode(7, OUTPUT);

                            }

                            void loop() {
                            static unsigned long oldTime = 0;
                            int switchStatus = 0;
                            if (millis() >= oldTime + CHECK_MS) {
                            oldTime = millis();
                            switchStatus = CheckSwitch();

                            if (switchStatus == 0) {
                            //no button press

                            } else if (switchStatus == 1) {
                            // single press
                            switch (spbutton) {
                            case 0: // no butto, why are wh here
                            break;
                            case 1: // mode
                            modeSend();
                            break;
                            case 2: // next up
                            trkUpSend();
                            break;
                            case 3: // next down
                            trkDnSend();
                            break;
                            case 4: // mute
                            muteSend();
                            break;
                            case 5: // vol up
                            volUpSend();
                            break;
                            case 6: // vol down
                            volDnSend();
                            break;
                            }
                            } else if (switchStatus == 2) {
                            //double press
                            switch (spbutton) {
                            case 0: // no butto, why are wh here
                            break;
                            case 1: // mode
                            sourceSend();
                            break;
                            case 2: // next up
                            trkUpSend();
                            break;
                            case 3: // next down
                            trkDnSend();
                            break;
                            case 4: // mute
                            muteSend();
                            break;
                            case 5: // vol up
                            volUpSend();
                            break;
                            case 6: // vol down
                            volDnSend();
                            break;
                            }
                            } else if (switchStatus == 3) {
                            //hold
                            switch (spbutton) {
                            case 0: // no butto, why are wh here
                            break;
                            case 1: // mode
                            modeSend();
                            break;
                            case 2: // next up
                            trkUpSend();
                            break;
                            case 3: // next down
                            trkDnSend();
                            break;
                            case 4: // mute
                            muteSend();
                            break;
                            case 5: // vol up
                            volUpSend();
                            break;
                            case 6: // vol down
                            volDnSend();
                            break;
                            }
                            }

                            }
                            }

                            // Service routine called by a timer interrupt
                            int CheckSwitch() {
                            static uint16_t State = 0; // Current debounce status
                            static int curTime = 0;

                            State=(State<<1) | !RawKeyPressed() | 0xe000;
                            if (!spFlag) {
                            if (hpFlag) {
                            if (State == 0xe000) {
                            return 3;
                            } else {
                            hpFlag = 0;
                            }
                            }
                            if (State==0xf000) {
                            spFlag = 1;
                            hpFlag = 1;
                            dpFlag = 1;
                            curTime = 0;
                            spbutton = button;
                            return 0;
                            }
                            }
                            if (hpFlag && State != 0xe000) {
                            hpFlag = 0;
                            }
                            if (spFlag && hpFlag && curTime > HOLD_MS/CHECK_MS) {
                            spFlag = 0;
                            dpFlag = 0;
                            return 3;
                            } else if (spFlag && dpFlag && State == 0xf000 && curTime < DOUBLE_MS) {
                            spFlag = 0;
                            hpFlag = 0;
                            dpFlag = 0;
                            return 2;
                            } else if (spFlag && !hpFlag && curTime > DOUBLE_MS) {
                            spFlag = 0;
                            hpFlag = 0;
                            dpFlag = 0;
                            return 1;
                            } else {
                            curTime = curTime + CHECK_MS;
                            return 0;
                            }
                            }

                            boolean RawKeyPressed() {
                            int anaPin = 0;
                            anaPin = analogRead(0);
                            if (anaPin > NO_B - 20) {
                            button = 0;
                            return 0;
                            } else if (anaPin > MODE_B - 20 && anaPin < MODE_B + 20 ) {
                            button = 1;
                            return 1;
                            } else if (anaPin > NXTU_B - 20 && anaPin < NXTU_B + 20 ) {
                            button = 2;
                            return 1;
                            } else if (anaPin > NXTD_B - 20 && anaPin < NXTD_B + 20 ) {
                            button = 3;
                            return 1;
                            } else if (anaPin > MUTE_B - 20 && anaPin < MUTE_B + 20 ) {
                            button = 4;
                            return 1;
                            } else if (anaPin > VOLU_B - 20 && anaPin < VOLU_B + 20 ) {
                            button = 5;
                            return 1;
                            } else if (anaPin < VOLD_B + 20 ) {
                            button = 6;
                            return 1;
                            } else {
                            button = 0;
                            return 0;
                            }
                            }

                            //-----------SOURCE------------------
                            void sourceSend() {
                            //first send 8ms high
                            digitalWrite(alpPin, HIGH);
                            delay(8);
                            // send 4.5ms low
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(4500);

                            for (int i = 0; i <= 47; i++) {
                            //send bit for 0.5ms
                            if (source[i] == 1 ) {
                            digitalWrite(alpPin, HIGH);
                            } else {
                            digitalWrite(alpPin, LOW);
                            }
                            delayMicroseconds(500);
                            // wait 0.5ms
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(500);
                            }
                            // send 41ms low
                            digitalWrite(alpPin, LOW);
                            delay(41);
                            }


                            //---------MODE-----------------------------------------------
                            void modeSend() {
                            //first send 8ms high
                            digitalWrite(alpPin, HIGH);
                            delay(8);
                            // send 4.5ms low
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(4500);

                            for (int i = 0; i <= 47; i++) {
                            //send bit for 0.5ms
                            if (entPlay[i] == 1 ) {
                            digitalWrite(alpPin, HIGH);
                            } else {
                            digitalWrite(alpPin, LOW);
                            }
                            delayMicroseconds(500);
                            // wait 0.5ms
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(500);
                            }
                            // send 41ms low
                            digitalWrite(alpPin, LOW);
                            delay(41);
                            }


                            //---------NEXT UP-----------------------------------------------
                            void trkUpSend() {
                            //first send 8ms high
                            digitalWrite(alpPin, HIGH);
                            delay(8);
                            // send 4.5ms low
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(4500);

                            for (int i = 0; i <= 47; i++) {
                            //send bit for 0.5ms
                            if (trkUp[i] == 1 ) {
                            digitalWrite(alpPin, HIGH);
                            } else {
                            digitalWrite(alpPin, LOW);
                            }
                            delayMicroseconds(500);
                            // wait 0.5ms
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(500);
                            }
                            // send 41ms low
                            digitalWrite(alpPin, LOW);
                            delay(41);
                            }

                            //---------NEXT DOWN----------------------------------------------
                            void trkDnSend() {
                            //first send 8ms high
                            digitalWrite(alpPin, HIGH);
                            delay(8);
                            // send 4.5ms low
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(4500);

                            for (int i = 0; i <= 47; i++) {
                            //send bit for 0.5ms
                            if (trkDn[i] == 1 ) {
                            digitalWrite(alpPin, HIGH);
                            } else {
                            digitalWrite(alpPin, LOW);
                            }
                            delayMicroseconds(500);
                            // wait 0.5ms
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(500);
                            }
                            // send 41ms low
                            digitalWrite(alpPin, LOW);
                            delay(41);
                            }


                            //---------MUTE---------------------------------------------------
                            void muteSend() {
                            //first send 8ms high
                            digitalWrite(alpPin, HIGH);
                            delay(8);
                            // send 4.5ms low
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(4500);

                            for (int i = 0; i <= 47; i++) {
                            //send bit for 0.5ms
                            if (mute[i] == 1 ) {
                            digitalWrite(alpPin, HIGH);
                            } else {
                            digitalWrite(alpPin, LOW);
                            }
                            delayMicroseconds(500);
                            // wait 0.5ms
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(500);
                            }
                            // send 41ms low
                            digitalWrite(alpPin, LOW);
                            delay(41);
                            }

                            //---------VOL UP-----------------------------------------------
                            void volUpSend() {
                            //first send 8ms high
                            digitalWrite(alpPin, HIGH);
                            delay(8);
                            // send 4.5ms low
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(4500);

                            for (int i = 0; i <= 47; i++) {
                            //send bit for 0.5ms
                            if (volUp[i] == 1 ) {
                            digitalWrite(alpPin, HIGH);
                            } else {
                            digitalWrite(alpPin, LOW);
                            }
                            delayMicroseconds(500);
                            // wait 0.5ms
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(500);
                            }
                            // send 41ms low
                            digitalWrite(alpPin, LOW);
                            delay(41);
                            }


                            //---------VOL DOWN-----------------------------------------------
                            void volDnSend() {
                            //first send 8ms high
                            digitalWrite(alpPin, HIGH);
                            delay(8);
                            // send 4.5ms low
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(4500);

                            for (int i = 0; i <= 47; i++) {
                            //send bit for 0.5ms
                            if (volDn[i] == 1 ) {
                            digitalWrite(alpPin, HIGH);
                            } else {
                            digitalWrite(alpPin, LOW);
                            }
                            delayMicroseconds(500);
                            // wait 0.5ms
                            digitalWrite(alpPin, LOW);
                            delayMicroseconds(500);
                            }
                            // send 41ms low
                            digitalWrite(alpPin, LOW);
                            delay(41);
                            }
                            Attached Files

                            Comment


                            • #15
                              if you have questions just ask.

                              Comment

                              Working...
                              X