Review: MPC Remote Starter

When my wife said that for Christmas she wanted a remote starter for her 2013 Honda CRV, I reflexively jumped for joy inside. “Yes! A new project!” Merry Christmas to me! Keep in mind I’m not a car guy. I know squat about them. But I figured it couldn’t be THAT hard. Step 1 – Push button. Step 2 – Car starts. How complicated could the electronics actually be, am I right? Mmmm hmmm.

It didn’t take long for me to find a remote starter kit online. The one I purchased cost $189.95 and is made by MyPushCart. The Amazon reviews for MPC remote starters were mostly four and five stars and had mostly comments like “Easy to install!” and “Plug and Play!”

Side Note: Guys, when your wife says she wants a remote starter for Christmas, don’t buy a kit, wrap the box, and put it under the tree. She will NOT be impressed Christmas morning.

“What do you mean you still have to install it?!”

“It’s -10 degrees outside. Just when are you going to get around to that?”

“Can you even do this kind of thing?”

*sigh*

The Unboxing

Unboxing the kit was pretty intimidating. The first thing I saw was a slip of paper with a big red STOP sign. It looked to contain some useful nuggets of information. Of course, I immediately sat it to the side. Beneath that piece of paper was a whole mess of wires, switches, and boxes. Nestled in the very bottom of the box was a little booklet entitled “Remote Start Kit Installation Instructions.” That booklet contained a bunch of technical jargon and wiring diagrams. Nothing looked plug-and-play. The booklet contained very few pictures. And it certainly contained no step-by-step instructions. Uh oh.

Once I was filled with a sufficient level of “I’m-in-way-over-my-head” anxiety, I revisited the paper with the big STOP sign. It instructed me to visit a website and enter a code. It said that I’d then be able to download a “tip sheet” to help with installation.

It turns out that the tip-sheet is the Rosetta Stone for the whole installation process. It provides step-by-step instructions. It shows pictures of the kinds of existing connectors to look for, the order in which to hook things up, and the steps for programming the hardware to respond to your key fob. You absolutely need this document. It perhaps should have been included in the box. But I guess a downloadable is ok too.

Plug-And-Play?

MyPushCart doesn’t actually make most of what’s in the remote starter kit. It sources the electronic components from third party vendors, such as Fortin and CrimeStopper. MyPushCart’s value-add is that they supply wiring harnesses, firmware programming, and tech support that allows an otherwise complicated installation to be more or less plug and play.

Much of the wiring in the box doesn’t actually get used. In my case, I only needed 4 cables, all of which had connectors that fit an existing plug either somewhere in the vehicle or in one of the little included boxes. I suspect the extra wiring is included in these kits simply because it comes with the third party kits. MPC could have thrown it out, but they did the honorable thing and included it. The “Remote Start Kit Installation Instructions” that I previously mentioned was actually from one of those third party kits. It’s not needed at all for a MyPushCart install. Just like the extra wiring, this booklet came along for the ride.

Installation

For the 2013 Honda CRV kits, all of the installation occurs beneath the steering column. You have to remove the steering column cover for this. This isn’t difficult. When you turn the steering wheel to one side, you can see a little slot where you can insert a pry-tool, such a flathead screwdriver. If you pry this open, turn the wheel, and then pry the other side open, the top cover will just pop-up and expose Philips-head screws hidden beneath the pry-slots. There’s a third Phillips screw hidden way underneath the steering column. After all three of these screws are removed, the steering column cover should pop right off and expose an extremely neat and wirey mess.






At this point you might be asking yourself two questions – 1) Should I disconnect the battery for rest of this install? And 2) Is there a risk of setting off the airbag?

As for disconnecting the battery, you’ll at least need to be able to turn the steering wheel to remove the cover. Later you’ll need power to sync and test the kit components. But if the idea of leaving the battery connected while you’re disconnecting and reconnecting things makes you uncomfortable, please, by all means disconnect it. You can always reconnect it when you need it. I didn’t bother and everything went ok. But don’t let my blind confidence deter you from doing what makes you comfortable.

What about the airbag? The risk is pretty low so long as you don’t go Dora the Explorer on any wiring the tip-sheet doesn’t talk about. Keep in mind, though, that you are working in the vicinity of the airbag. The airbag’s electronic connections are exposed and accessible once the steering column cover is off. Just be mindful and deliberate about what you do and you should be fine.

There are only two steering column connections that need to be made. One is for the transponder plug and one is for the ignition plug. The MPC kit includes cables that allow the little remote starter controller boxes from the kit to work as sort of “men-in-the-middle” on these connections.

The first connection that needs to be made is the transponder plug. You disconnect the existing transponder plug connection and insert the provided T-harness. The second connection is for the ignition plug. Just as with the transponder plug, you disconnect the existing plug and insert the ignition T-harness in between.

I found the ignition T-harness step to be particularly tricky. The vehicle cabling is wrapped super-tight which made disconnecting the existing connection extremely awkward.

At this point, the tip-sheet tells you to secure the new wiring and replace the steering column cover. My advice is to hold off until you verify that everything works. Also, depending on where you place your remote starter boxes and slack wiring, you might need better access and visibility to the area beneath the steering column than you’d get with the cover on.

The next thing you have to do is connect one of the kit boxes to ground on the car. This box is the CrimeStopper RS000-G5, referred to as the “RS brain” or sometimes simply as “RS” in the tip-sheet. The cable included for this features a 12-pin connector on the “RS-brain” end and three wires on the other end that are labeled “Parking Lights”, “Ground”, and “Hood Pin”. I have no idea what the “Parking Lights” or “Hood Pin” connections were for. I simply wrapped those wires up with black tape and tucked them away. The “Ground” connection is meant to be attached to a bare-metal spot on the vehicle. It has a little ring-connector that looks designed be screwed down.




I first thought that finding a bare-metal connection point beneath the steering column would be a challenge. But I managed to find an existing screw that had enough slack to accept both the ground connection and a spare nut that I found in my trusty box of “mystery screws and nuts”. Once the ground connection is made, you can plug the 12-pin plug into the RS.

The next step is to sync the electronic boxes and the car together. This simply involves connecting the EVO-ALL and the RS using a single 4-pin wire, plugging in all the T-harness connections to the EVO-ALL, and then performing a series of steps that involve button presses and turning the key in the ignition. It takes less than a couple of minutes. The tip-sheet describes all of this in detail so I won’t duplicate it here.

The tip-sheet also includes instructions for programming the RS. However, my kit included a sticker on the RS that said, “This module has been preprogrammed by MyPushcart for 3 times lock and is ready for use.” As a result, I didn’t actually have to do any of those steps. It looks straightforward though.

From this point, everything just worked. I tested it by simply pushing the lock button on the vehicle remote three-times slowly. The console lit up, and then a couple of seconds later the vehicle started on its own. It’s at this point that I began the process of trying to organize and situate the wiring and controller boxes. This is BY FAR the most difficult and tedious process of the entire thing. The cabling and boxes are bulky to say the least. Finding a spot for everything wasn’t easy. I basically zip-tied and velcroed the whole mess to anything that wasn’t designed to move. It wasn’t pretty. But I kept things out of the way and that’s the most important thing. The biggest challenge is finding a way to position the T-harness plugs so that the steering wheel cover can go back on. The cover doesn’t leave a lot of room for anything extra around the steering column area. So figuring out where things should go involved a lot of trial and error.

Tech Support

I said earlier that one of the value-adds that MPC brings is in tech support. I want to bring some extra attention to this. MPC’s tech support is AWESOME! I only used their email tech support. But I used it a LOT. I peppered them with photos with annotations and lots of questions relating to confusion over connectors, the names of things, a few installation missteps, etc., etc. They ALWAYS responded – if not the same day, usually the next day. Kudos to those guys for being so patient with me.

Conclusion

Do I recommend an MPC remote starter kit? It depends. If you’re a DIY-er, absolutely. If you’re just into the idea of having a remote starter and don’t care about how it gets installed, MPC may still be an option. Maybe you have a tinkerer in your family you could barter with. MPC also has a network of installers that might be an option for you as well, but that’ll be an extra cost.

At the time of this writing, it’s been a few weeks since I installed the MPC kit. My wife has only reported one weird occurrence of the car starting unexpectedly while unlocking and locking the doors. There’s some confusion around the sequence of remote button presses she actually used, so we’re not 100% sure what happened there. We’ve also discovered it can be a little tricky to get the timing of the button presses just right. Too-fast, nothing happens. Too-slow, nothing happens. Get it right, it’s not immediately obvious because the car takes a couple of seconds to start. Practice makes perfect, I suppose.

All in all, this was a fun kit to install. It’s super interesting and I learned a lot. I’m sure you will too.

GDB Tips and Tricks #6: Examining Data Types

It’s often the case that while stepping through code you encounter a variable that’s unknown to you. If it doesn’t appear to be relevant to the task at hand, perhaps you choose to ignore it. But if it may have some significance to the problem you’re trying to solve, you’ll obviously need to learn a bit more about it.

The first thing you might want to learn about the variable is its type. You can turn to the source code to seek this out. If the type turns out to be a struct/class, typedef, or type alias, you might need to do a bit more spelunking to fully understand what kind of data is in play.

Fortunately, gdb provides us with a couple of commands to help us out when it comes to data types – whatis and ptype

whatis

The whatis command tells us the superficial type of a variable or expression. By that I mean, it will show the type of something as it appears in code. Things like typedefs or type aliases aren’t “unrolled.” But the whatis command accepts expressions too. So if you’d like unroll a typedef or type alias, you can do so manually. Let’s see some examples.

Let’s use the following snippet of code.

struct MyStruct
{
    int x;
    MyStruct() : x(2) {}
};
 
using _IntegerValue = int;
using IntValueAlias = _IntegerValue;
 
int main()
{
    int a = 0;
    IntValueAlias b = 1;
    MyStruct c;
    return 0;
}

After we compile, launch gdb, and step into main, let’s ask gdb to tell us the types of the variables a, b, and c.

(gdb) whatis a
type = int
(gdb) whatis b
type = IntValueAlias
(gdb) whatis c
type = MyStruct

As you’d probably expect, gdb prints “int” when we ask about variable a’s type. When we ask for the type of variable b, we see “IntValueAlias”. You’ll note from the code snippet above that IntValueAlias is just a type alias for another type alias which isn’t shown in gdb’s output. When asked about the type of c, we get the struct name, “MyStruct”.

If we want to dig a bit further on the type alias, we can use whatis like so.

(gdb) whatis IntValueAlias
type = _IntegerValue
(gdb) whatis _IntegerValue
type = int

If you expect whatis to give you more detailed information about structures and classes, you’ll be disappointed to know that it doesn’t help you out. The documentation for whatis actually claims that the /M option will show class methods and that /T shows typedefs defined in a class, but I’ve never been able to get these options to do anything.

(gdb) whatis MyStruct
type = MyStruct

I should mention a couple of things about templates and whatis. The whatis command substitutes template parameters and typedefs when displaying type information for variables of template types. This means you can see pretty nasty stuff.. For example, take this snippet of code.

int main()
{
    std::string a;
    std::map<std::string, std::string> b;
    return 0;
}

If we ask gdb what the type of a is, we’ll see the following.

(gdb) whatis a
type = std::__cxx11::string

That’s not exactly what we typed in our code, but it’s workable.

What about the type of b?

(gdb) whatis b
type = std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >

As my two-year old daughter would say, “YUCK!”. Unfortunately, it is what it is and we have to work with it.

ptype

The ptype command is a bit more heavy duty than whatis. Think of it as whatis on steroids. In the case of typedefs and type aliases, ptype always unrolls them. In the case of structs and classes, ptype gives much more detailed information, which includes methods and member variables. In the case of templates, well, we get a lot more yuck.

Let’s look again at our first example.

struct MyStruct
{
    int x;
    MyStruct() : x(2) {}
};
 
using _IntegerValue = int;
using IntValueAlias = _IntegerValue;
 
int main()
{
    int a = 0;
    IntValueAlias b = 1;
    MyStruct c;
    return 0;
}

Just as we did before, let’s examine the types of variables a, b, and c. But instead of using whatis, let’s use ptype.

(gdb) ptype a
type = int
(gdb) ptype b
type = int
(gdb) ptype c
type = struct MyStruct {
    int x;
  public:
    MyStruct(void);
}

The type of a is shown as int, just as before. The type of b has been unrolled all the way down to the type of the original type alias, which is int. The type of c now shows the layout of the MyStruct struct.

I’ll spare you from a ptype example using templates. As you can imagine, a lot more information is displayed as compared to whatis.

Conclusion

Both whatis and ptype are handy tools for inspecting data types. You could certainly accomplish the same types of things manually within your IDE. But these commands allow you to keep your focus on the debugging session instead of your IDE, which hopefully means being more efficient in tracking down the source of bugs.

DIY Learning Tower


As soon as my daughter learned to walk, my wife became convinced that she needed a learning tower. “What the heck is a learning tower?!” I asked. She then proceeded to flood my inbox with Amazon links.

A learning tower, as it turns out, is a neat little structure that kids can climb into and have a platform to stand on. It allows them to do things that they’d ordinarily need to be taller to do. This includes baking with a parent, washing hands at the sink, retrieving items high on a shelf, etc.

It wasn’t until my daughter could sprint through the house without tripping over herself that I began to warm up to the idea. But even then I wasn’t so sure. For a long time, she was skiddish with just about everything. For instance, I was never able to put her in one of those toddler backpacks. Every time I tried, she’d lose her mind. So I was skeptical that she’d be willing to even stand in a learning tower. But I eventually came around.

At the time we began shopping for a learning tower, all of the seemingly decent ones came in somewhere between $150-$200. It pained me to think about throwing that kind of money at something my daughter would turn her nose up at. The towers that I saw didn’t even look all that complicated to build. I thought I might be able to save a few bucks by building one myself. So I began looking at learning tower plans online.

I eventually came across a set of plans by a lady named Ana White. Her take on the learning tower looked simple enough. So over the Thanksgiving holiday, I decided to give it a go.

Ana White’s tower is super easy to build. And cheap. I think I spent around $50 all-in on materials. The project took maybe 3-4 hours to complete. Below is a picture of how it turned out.

There are some slight differences between my version and Ana White’s. Ana’s plan calls for a mix of screws and wood glue for assembling. The amount of screws she calls for on some of the more stress-bearing areas made me extremely nervous. I doubled up screws on things like the ladder rungs, platform supports, and the top bars. And because of that, I had to slightly offset the placement of some things. But that’s pretty much it. Ana’s plans are great. If you’re interested in building a learning tower for your kid, I highly recommend checking out Ana White’s plans.

How does my daughter like her learning tower? She LOVES it. She began climbing into it on her own pretty much right away. It’s definitely made hand-washing easier. She really, really likes being at counter-level. That’s now where she wants to snack. Something that was unexpected is that she will actually grab the learning tower and drag it around to where she wants it to be. I knew that would happen eventually. But she’s not even 2 yet, so that was a bit of a surprise.

Estimated Cost: $50
Wood-working skill level: Novice