TrueJournals

I think this would be a good place to archive my explanation of NJoy programming.  I was asked about how the patterns in mce.ini for the n810 work, with PatternError given as an example.  This was my reply:

The different sections of the line are separated by semicolons. So, priority is the first part, then a semicolon, then the “ScreenOn” value, then a semicolon, etc. So, I’ll use your example and point out each section of the programming.

0;1;0;40002000200040ff200020000000;0000;0000

To make this easier, I’m going to assign an index to each section of the command. I’ll split the string up by the semicolons. We’ll say the first character (a zero, in this case) has an index of 1. The second part of the split (a one), has an index of 2, etc, etc.

0;1;0;40002000200040ff200020000000;0000;0000
Index 1 defines the priority. If two patterns trigger at once, items with a higher priority (lower number for this section), take precedence, because only one pattern can be going at once. Since the priority is 1 (0 being the highest priority, 255 being the lowest), this pattern will display instead of almost any other pattern (the exception is patterns that have a priority of 0)

0;1;0;40002000200040ff200020000000;0000;0000
Index 2 defines whether or not the pattern should fire based on what state the display is in. In this case, it’s a 1, which mce.ini tells us means “show pattern even when the display is on”. So, this pattern will display no matter what.

0;1;0;40002000200040ff200020000000;0000;0000
Index three gives the timeout. This can tell the pattern to stop firing after a certain amount of time. In this case, it’s a zero, which means that the pattern will never stop firing (unless it’s told to).

0;1;0;40002000200040ff200020000000;0000;0000
Index four starts the actual programming of the LED. Index four gives the programming of the RED LED. It also gets a bit more complicated here. We have to split this section up into strings of four characters each in order to understand the programming. This is what the pattern looks like, split into four-character strings, with each string separated by a pipe (|):
4000|2000|2000|40ff|2000|2000|0000
So, there are seven different commands given to the red LED. Let’s take a look at them one by one:

1. 4000 — This sets the brightness of the LED (anything starting with a 40 will change the brightness). I believe this tells the LED to turn off (0 brightness). I believe that ff would be 100% brightness.
2. 2000 — This bumps the brightness up over a certain amount of time. This gets REALLY confusing. The first two characters, 20, tell how long it should take to change the brightness. 20 is in the 01 – 3f range, so we get “short” steps. If I understand this, we get 19 “short” steps of time ~0.49ms, so this should take about 9.31 milliseconds. The next two characters, 00, defines how many steps in brightness the LED should take. 00 is no change, so the pattern will pause for about 9.31 milliseconds.
3. 2000 — Because this is the same command as above, this will also create a 9.31 millisecond pause.
4. 40ff — Again we see a 40. This says to change the channel brightness. This time, we’re changing it to ff, which should be 100% brightness. So, this command turns the LED on.
5. 2000 — This creates another 9.31 ms pause.
6. 2000 — This creates another 9.31 ms pause.
7. 0000 — This tells the pattern to loop (“jump to the start of the pattern”).

So, the red LED will turn off, pause for (2*9.31 ms =) 18.62 milliseconds, turn on, pause for another 18.62 milliseconds, then loop.

0;1;0;40002000200040ff200020000000;0000;0000
Index five gives the pattern for the GREEN LED. This is a very exciting pattern. It simply tells the pattern to repeat again and again and again. So… nothing happens with the green LED.

0;1;0;40002000200040ff200020000000;0000;0000
Index six gives the pattern for the BLUE LED. Again, very exciting. The blue LED does… nothing.

I hope this helps you understand how the programming works.

This will be the second in my series of security topics from a non-security expert, I suppose.  I just calls ‘em hows I sees ‘em.

As you may or may not know, I will be attending Valparaiso University this Fall as a Freshman.  When I attended Valparaiso’s Freshman orientation program, they taught us a lot about their online systems.  One thing I learned was that I will need to change my password every 185 days, and when I change it, it can’t be similar to whatever I had last time.  The idea here is that this will be more secure, because hackers will never know your password for an extended period.  However, I see a problem with this.

Forcing me to change my password to something completely different means forcing me to memorize a new password, something completely different, too.  Now, personally, I don’t think this will be much of a problem, because I’m pretty good at memorizing things.  However, if you aren’t that good at memorizing, this could cause a big problem: the urge to write down your password.  As anyone could tell you, writing down a password immediately creates a security risk, because anyone could see it written on a piece of paper, or take the paper, etc.  The safest place for a password is in your brain, and in your brain only.

So, is forcing users to change their password really more secure?  For some people, I think it will help, but I think it’s a practice that could only hurt others.  A better idea would be to enforce good password practice: have users create a nice, good length, password, containing at least one letter, number, capital letter, and special character.  Want to go for more security?  Force it to start and end with a letter.  Don’t just let the user tack an exclaimation mark on an otherwise easy-to-guess password.

Overall, I don’t think there will ever be a formula for password security.  There is no one end-all be-all tip I can give for keeping your password away from hackers.  Perhaps forcing people to change their password every x days really does help security.  But, I’d like to see some concrete proof of this before I believe it.

Rumble is a pretty hot topic among game controllers.  When the Sony announced that the PS3 controller wouldn’t have rumble, gamers and bloggers got angry.  Joystiq gives a perfect example of this, summarizing the opinions of others.  And while the general consensus was that rumble wouldn’t hurt Sony, it would just help them if they had it, it’s still a shame to see a company remove such a nice gaming feature.

Three years later, in walks Microsoft.  Perhaps you’ve heard of Project Natal.  It’s an interesting concept.  Instead of forcing you to hold a control, sit down and play your video games, we’ll FORCE you to stand up and fight your opponents like a man.  Microsoft looked at the success of the Wii, and basically said, “We can take this one step farther…”  If it works well, and Microsoft can keep the price point low, then I have a feeling it will go over big.  If not, then it’ll flop and be part of gaming history, much like the Power Glove and Sega Activator.

However, there’s a strange point that all the articles I’ve read have been missing.  Without a controller to hold, there will be no rumble, no force feedback.  And while, for the most part, this is really just a novelty… There are some games that might be lacking without this crucial detail.  Yet, the blogosphere hasn’t exploded.  In just three years, the Internet has gotten over the joy of having rumble in a controller.

Maybe we never really needed it to begin with, and Sony just showed us this by removing it.  Personally, I’ve never used a PS3, but if the consesus was that it wasn’t a critical point, then that’s not what’s hurting its sales.  Or, maybe, Microsoft just can’t do any evil in the gaming world.  Sure, Microsoft is evil in the computing world… but they seem to be a god in the gaming world, much like Apple is a do-no-evil god in the computing world.

So, what will come out of this?  Maybe we’ll start to see more controllers without rumble.  Rumble hit it big, but maybe the novelty is dying off now, and we realize that we don’t really need rumble to play a good video game.  Or, perhaps Microsoft’s “controller” will flop, and systems will still keep rumble in their controllers.  Of course, Natal could always flop AND we lose rumble in controllers.  Only time will tell.