First step

Read whoji’s post on How to setup wordpress on Andrew File System(AFS) @ CMU. Though it’s not complete, it’s very good point to start. He explains every step in detail so that it should be quiet easy to follow. Once you followed his instructions, you have a working wordpress blog on your account. Here, I assume that you installed the blog at ~/www/blog.

Problem: Security Issue

So, what’s the problem? Even if your-just-installed-blog works now, there is a security problem in this configuration. Because of the way AFS works, any user in the AFS system can access your wp-config.php file where you put your MySQL user ID and password!

Please note that changing linux permission on your blog directory does not help. If you read Computer Club’s documentation, you will find that they already mentioned this problem (and also a possible solution).

Solution

Script are run by contrib.your_andrew_ID@club.cc.cmu.edu account. Therefore, the solution is to put wp-config.php file into a directory where no one but contrib.your_andrew_ID has an access and use that file instead of the one at ~/www/blog. Here, we use ~/www/blog/secret as an example.

1. Create a folder where you hide your wp-config.php file.

   ~/www/blog> mkdir secret
   

2. Move wp-config.php to the secret directory

   ~/www/blog> mv wp-config.php secret/
   

3. On the secret folder, give no permission to system:anyuser:

   ~/www/blog/secret> fs sa . system:anyuser none
   

4. Give read/listing permissions to contrib.your_andrew_ID@club.cc.cmu.edu:

   ~/www/blog/secret> fs sa . contrib.your_andrew_ID@club.cc.cmu.edu rl
   

5. Substitute all the occurrences of wp-config.php with secret/wp-config.php in ~/www/blog/wp-load.php and ~/www/blog/wp-admin/setup-config.php files.

• Sample SOP: sample.pdf
• Git Repository: https://bitbucket.org/soonhok/sop/src

Requirement

• It uses Adobe Caslon Pro font family. If you don’t have them, you cannot compile the SOP. For more information about the fonts, please visit here.

How to Compile

It uses xelatex to use custom fonts. After modifying the downloaded main.tex, type the following on the terminal:

$ xelatex main.tex

I only tested it on OSX machines, you may have problems on other platforms such as Windows or Linux.

• multi-task
• concurrent movements
• log via USB
• support its own programming language
• transfer a program via USB

Turing Machine

Turing Machine is an abstract computing device which was contrived by Alan Turing. It runs the following algorithm:

1. Read : Read the current cell of the tape.
2. Transition : Determine the next state, output, and shift direction based on the current state and the content of the current cell. If the new state is either Accept or Reject state, stop the machine.
3. Write : If needed, change the value of the current tape cell.
4. Move : Move the tape to the left or right based on the result of 2.
5. Goto 1.

1. Simple, Single-task Turing Machine (Download)

We start with a simple implementation. This implementation has the following properites (limitations):

• Single-task
• Controlled by a Transition Relation
• Serialized Movement: Read - Write - Move, one by one.
• No Logging

1.1 Main Loop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

TASK(TM)
{
    while(true)
    {
        /* Read */
        input = Read();

        /* Make transition */
        (state, output, dir) = transition(state, input);
        if(state == HALT_STATE)
            HALT;

        /* Write (Optional) */
        if(input != output) {
            write(output);
        }

        /* Move */
        move(dir);
    }
}

The main loop is a direct translation of the algorithm presented above. Repeatedly, it reads the tape cell, makes a transition which is defined in transition function, optionally changes the current tape cell, and moves the tape as directed.

1.2 Reader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

_Bool read()
{
    U16 color;
    _Bool input;

    /* 1. Move READ Header to TAPE */
    nxt_motor_set_speed(READ_MOTOR, SPEED, 1);
    while(nxt_motor_get_count(READ_MOTOR) <= READ_REV) {
        /* do nothing */
    }
    nxt_motor_set_speed(READ_MOTOR, 0, 1);

    /* 2. Read Sensor Value */
    ecrobot_set_nxtcolorsensor(COLOR_SENSOR, NXT_LIGHTSENSOR_GREEN);
    ecrobot_process_bg_nxtcolorsensor();
    color = ecrobot_get_nxtcolorsensor_light(COLOR_SENSOR);
    input = color < COLOR_THRESHOLD ? 1 : 0;
    ecrobot_set_nxtcolorsensor(COLOR_SENSOR, NXT_LIGHTSENSOR_NONE);
    ecrobot_process_bg_nxtcolorsensor();

    /* 3. Move READ Header back */
    nxt_motor_set_speed(READ_MOTOR, -SPEED, 1);
    while(nxt_motor_get_count(READ_MOTOR) >= 0) {
        /* do nothing */
    }
    nxt_motor_set_speed(READ_MOTOR, 0, 1);

    return input;
}

read function does three operations:

1. Move the READ header to the TAPE
2. Read the sensor value
3. Move the READ header back

Let’s focus on the actual reading operation (in step 2) because it is relatively trivial to move the header back and forth (step 1 & 3). At line 14, it turns on the color sensor and set it to NXT_LIGHTSENSOR_GREEN mode. At line 16, ecrobot_get_nxtcolorsensor_light function returns the raw value which measures the reflection around the sensor. We use the pre-defined constant COLOR_THRESHOLD to determine whether the given raw value is interpreted as 0 or 1. (line 17). Then, it turns off the light sensor (line 18).

Note that it is necessary to call ecrobot_process_bg_nxtcolorsensor function at line 15 and line 19. When we change the sensor mode by calling ecrobot_set_nxtcolorsensor at line 14, nothing really happens on the sensor side. It only changes the sensor status on the memory without affecting the sensor itself. It is the job of ecrobot_process_bg_nxtcolorsensor function which makes requested changes on the sensor side and copies the raw value of the sensor to the memory. If we do not call ecrobot_process_bg_nxtcolorsensor at line 14, 1) the sensor is not set to green light mode and 2) the value we read at line 16 can be an outdated value– it is the value of the sensor when ecrobot_process_bg_nxtcolorsensor function was called last time.

1.3 Writer

1
2
3
4
5
6
7
8
9
10
11

void write(_Bool output)
{
    int sign = output == 1 ? 1 : -1;
    nxt_motor_set_speed(WRITE_MOTOR, sign * SPEED, 1);
    while (sign * nxt_motor_get_count(WRITE_MOTOR) <= WRITE_REV) {
        /* do nothing */
    }
    nxt_motor_set_speed(WRITE_MOTOR, 0, 1);
    nxt_motor_set_count(WRITE_MOTOR,
                        nxt_motor_get_count(WRITE_MOTOR) % WRITE_REV);
}

Writing operation is simple. It flips the bit on the tape based on the output value – clockwise to write 0 and counter-clockwise to write 1. The constant WRITE_REV is defined to be 180.

1.4 Tape Mover

1
2
3
4
5
6
7
8
9
10
11

void move(_Bool dir)
{
    int sign = dir == RIGHT ? 1 : -1;
    nxt_motor_set_speed(TAPE_MOTOR, sign * TAPE_MOV_SPEED, 1);
    while (sign * nxt_motor_get_count(TAPE_MOTOR) <= TAPE_MOVE_REV) {
        /* do nothing */
    }
    nxt_motor_set_speed(TAPE_MOTOR, 0, 1);
    nxt_motor_set_count(TAPE_MOTOR,
                        nxt_motor_get_count(TAPE_MOTOR) % TAPE_MOVE_REV);
}

move function is similar to write. Based on the given argument dir – which is either LEFT or RIGHT, it rotates the motor to move the tape to the given direction. The constant TAPE_MOVE_REV is set to 1800 (five cycles).

Limitations

This implementation works well, however, there are limitations of this implementation.

• Single-task with polling : We have one big monolithic task doing every operation – read/write/move – in it. It uses busy-wait polling to control motors as the following code (part of move function).

1
2
3

   while (sign * nxt_motor_get_count(TAPE_MOTOR) <= TAPE_MOVE_REV) {
      /* do nothing */
   }

Problem: It wastes CPU cycles and prevent us from doing other tasks. We are going to improve this by implementing multi-task version.

• Controlled by a Transition Relation : In this implementation, we need to provide a transition relation to program the machine. For example, the unary addition program has the following transition relation:

This form is difficult to understand and maintain. We will introduce an assembly-like language to program the machine. With the new language, we may program the unary addition as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/* Before it meets the first ones */
0:  READ
    CJUMP1 1
    MOVE   L
    JUMP   0

/* scanning first operand */
1:  MOVE   L
    READ
    CJUMP1 1
    WRITE  1
    MOVE   L

/* scanning second operand */
2:  READ
    CJUMP0 3
    MOVE   L
    JUMP   2

/* last position */
3:  MOVE   R
    READ
    CJUMP0 ERR
    WRITE  0

/* computation finished, keep moving to the right until it ends */
4:  MOVE   R
    READ
    CJUMP1 4
    HALT

ERR:
    ERROR

• Serialized Movement: In the current implementation, Read/Write/Move operations occur one after another, even if it is physically possible to do them simulataneously in some cases. For example, the read header can start to move to the tape while the tape is being moved to the next position. The only constraint here is that the tape should not move when the colorsensor reads the value. By the same argument, we may move the writer lever and the read header simulataneously. However, we should be careful to avoid any physical collision. To implement concurrent movements, it is natural to program using multiple tasks. This extension will introduce more complexity to an implementation. We will see how to use our verification tool to make sure that an implementation has desired properties.

• No Logging : Currently, we do not have any logging feature so that it is difficult to check the internal status of the machine or debug a program. We will start to add logging by using the LCD display in the NXT brick. Then, we will use USB communication to output log messages to the connected computer.

• Installing LEGO Fantom driver for Mac OS
• Downloading GNU ARM toolchain
  • Note: This is version 4.6.2, not the latest version 4.7.1. I tried the latest one, however, it generated incorrect binaries which displayed broken strings once I ran them.
• Installing GNU ARM toolchain
  • Create directory work in home folder.
  • Mount downloaded .dmg file.
  • Move installer yagarto-4.6.2 from .dmg to ~/work.
  • Run installer. It will create directory ~/work/yagarto-4.6.2 and install toolchain to it.

• Download and install Wine via Homebrew

    brew install wine
  

• Installing nxtOSEK
  • Download nxtOSEK v2.161 and unpack it.
  • Download sam7_ecrobot.lds and replace with the one in nxtOSEK/ecrobot/c.
• Editing tool_gcc.mak to specify GNU ARM directory and target prefix in ecrobot.mak

1
2
3
4
5
6

...
GNUARM_ROOT = /Users/[your_home_dir]/work/yagarto-4.6.2
...

TARGET_PREFIX :=arm-none-eabi
...

• Editing ecrobot.mak to specify WINECONSOLE. If you use c++ instead of c, you may need to edit ecrobot++.mak

1
2
3
4
5
6
7
8

# Detect OS name 
...
UNAME := $(shell uname)
ifeq ($(UNAME), Darwin)
        # Mac OS X detected.
        WINECONSOLE := LANG=en_US.UTF-8 wineconsole
        LAUNCHER := $(WINECONSOLE)
...

• Download native nexttool for Mac OS X

• Re-building nxtOSEK libraries

  • Go to nxtOSEK/ecrobot/c++ and run:

     make all
     make release
    

  • Go to nxtOSEK/ecrobot/c and run:

     make all
     make release
    

  • Go to nxtOSEK/ecrobot/bios and run:

     make all
     make release
    

  • Go to nxtOSEK/ecrobot/nxtway_gc_balancer and run:

     make all
     make release
    

Introduction

Internship

A month ago, I started my summer internship at Software Engineering Institute, Carnegie Mellon working on verification of concurrent programs with Dr. Arie Gurfinkel and Dr. Sagar Chaki. We looked for an interesting example to demonstrate our verification tool and to learn how we can imporve it.

LEGO Mindstorms & nxtOSEK

Interestingly, Arie and Sagar have used concurrent programs written for LEGO Mindstorm as benchmarks of their verification tool. At first time, I got an impression that these LEGO programs are not realistic. However, I learned that I was wrong.

1. Those LEGO Mindstorms programs are running on the nxtOSEK platform.
2. A part of nxtOSEK is TOPPERS/ATK, which provided real-time multi tasking features proven in automotive industry.
3. Actually, “OSEK” in “nxtOSEK” is an open standard for automotive embedded systems, published by a consortium founded by the automobile industry including BMW, Robert Bosch GmbH, DaimlerChrysler, Opel, Siemens, Volkswagen Group, Renault and PSA Peugeot Citroën.
4. nxtOSEK’s real-time kernel is also compatible with μITRON 4.0 specification which is a de-facto industry standard in the embedded systems field.

Sometimes, things are more than what we see. This Mindstorms car looks like a toy, however it contains a complex embedded system inside.

CWI Turing Machine

After spending some time on searching for good examples, I found this fascinating Turing machine which was designed by researchers at CWI. I do recommend their [Video] if you have not watched it yet.

We decided to build this machine because of the following reasons:

• Simple Mechanics: All operations – reading, writing, and moving – can be done by simply rotating motors and reading a sensor. We do not need to worry about complex movements which are basically not our interest.
• Inherent Parallelism: Though the CWI TM is a single-thread program, it is natural to program a Turing machine using multiple threads.

0. Required Components

1. LEGO Mindstorms NXT 2.0 Kit (8547) ($280): Definitely, we need this one. This kit consists of one NXT brick, three servo motors, and four sensors (ultrasonic sensor, 2 touch sensors, and color sensor). To build this TM, we are going to use three servo motors and one color sensor.
   
2. Technic Parts ($20): It is not clear what components you really need even after reading the CWI webpage. They just mention that you need some other parts from LEGO Technic Kits. Watching their video several times, I figured out what we needed to build a machine with a 16-bit long tape.

Please note that you have to choose Black color when you buy 32014 Technic Angle Connector #6 (90 degree) because this part will be used as a *bit” in a tape.

1. Tape (16-bit)

Let’s build the tape first. Basically, 32014 Technic Angle Connector #6 (90 degree) – the L-shaped black part – plays the role of “bit”. Two bits are separated by either a 3713 Technic Bush – Red cylindrical object – or 6536 Technic Cross Block 1 x 2(Axle/Pin).

The bottom of the tape is not shown on the Video and it is actually quite tricky to figure out what there is. As you see in image 7 and 8, there are 3743 Technic Gear Rack 1 x 4 at the bottom of the tape, which are attached with 4274 Technic Pin 1/2.

2. Rail & Bridge

Building a rail and a bridge is not difficult. Make sure that the gap in the rail is three-hole wide so that the tape can fit in it.

3. Engine (Gears & Gear Worms)

This is the most interesting part of the machine. Here is a problem. We need linear movement to move the tape back and forth while our servo motor only provides circular movement. The CWI design solves this problem by using gear, gear worms, and gear racks.

My solution is simpler than the CWI design in a sense that mine does not use a bevel gear.

Once you finish up to step 6, please make sure that the gear worms do not move back and forth when you rotate the 24-teeth black gear.

You also need to place additional 3647 Technic Gear 8 Tooth on the rail to hold the tape stably (see the top and bottom parts of Engine #2 image).

4. Tape Mover

We need to transfer the drive from a motor to the engine part. First assemble the Tape Mover unit with a servo motor.

Then attach it to the bridge and engine part. Make sure that there is no movement of the motor when it runs.

5. Reader

The Reader unit consists of one servo motor and one color sensor. Once you assemble it, attach to the rail & bridge.

6. Writer

The Writer unit has a servo motor with a lever to flip a bit. It is important to align the Reader and Writer well so that they can read and write the same bit of the tape.

That’s it!

Once you finish all the steps, connect all the motors and the sensor to the NXT brick using cables. Now, you are ready to run this machine!