File content as of revision 4:0df8a61cbee9:

#include "mbed.h"
#include "Ultrasonic.h"

extern "C" {
#include "Controller_Slave.h"       /* Model's header file */
#include "rtwtypes.h"
}

static RT_MODEL_Controller_Slave_T Controller_Slave_M_;
static RT_MODEL_Controller_Slave_T *const Controller_Slave_M =
    &Controller_Slave_M_;                /* Real-time model */
static B_Controller_Slave_T Controller_Slave_B;/* Observable signals */
static DW_Controller_Slave_T Controller_Slave_DW;/* Observable states */
static real_T Controller_Slave_U_V;
static real_T Controller_Slave_U_D_S;
static uint8_T Controller_Slave_U_Master;
static boolean_T Controller_Slave_U_QA_EN;
static uint8_T Controller_Slave_Y_BRAKE;
static uint8_T Controller_Slave_Y_ACC;
static uint8_T Controller_Slave_Y_LED_RED;
static uint8_T Controller_Slave_Y_LED_GREEN;
static uint8_T Controller_Slave_Y_LED_BLUE;
static uint8_T Controller_Slave_Y_SLAVE;
void rt_OneStep(RT_MODEL_Controller_Slave_T *const Controller_Slave_M);
void step();


Ultrasonic sonic(D6,D7);  // Just call this funtion to initialize the ultrasonic sensor
// D2 trigger D4 echo
DigitalOut led_R(LED_RED);
DigitalOut led_G(LED_GREEN);
DigitalOut led_B(LED_BLUE);
DigitalIn  master(D5);
DigitalOut acc(D2);
DigitalOut brake(D3);
DigitalIn  qa(D4);
float V = 29;   // Set the vehicle speed here
Ticker t;
Serial  pc(USBTX, USBRX); // tx, rx
Serial  myrio(D1,D0 ); // tx, rx

int main()
{
    /* Pack model data into RTM */
    Controller_Slave_M->ModelData.blockIO = &Controller_Slave_B;
    Controller_Slave_M->ModelData.dwork = &Controller_Slave_DW;

    Controller_Slave_U_V = V;
    Controller_Slave_U_D_S = 50;
    Controller_Slave_U_Master = 1;
    Controller_Slave_U_QA_EN = true;

    /* Initialize model */
    Controller_Slave_initialize(Controller_Slave_M, &Controller_Slave_U_V,
                                &Controller_Slave_U_D_S, &Controller_Slave_U_Master,
                                &Controller_Slave_U_QA_EN, &Controller_Slave_Y_BRAKE,
                                &Controller_Slave_Y_ACC, &Controller_Slave_Y_LED_RED,
                                &Controller_Slave_Y_LED_GREEN, &Controller_Slave_Y_LED_BLUE,
                                &Controller_Slave_Y_SLAVE);


    t.attach(&step,0.1);
    led_B.write(1);
    led_G.write(1);
    led_R.write(1);
    master.mode(PullDown);
   // slave_out.write(1);
    while (true) {
        wait(0.2);
    }
    Controller_Slave_terminate(Controller_Slave_M);
}

void step()
{
    int var = 0;
    char str[10];
    if(myrio.readable()) {
        myrio.scanf("%s",str);
        var = atoi(str);
        pc.printf("%d \n",var);
    }
    V = var;
    Controller_Slave_U_V = V;
    Controller_Slave_U_D_S = sonic.read_cm();
    Controller_Slave_U_Master = master.read();
    Controller_Slave_U_QA_EN = qa;
    rt_OneStep(Controller_Slave_M);
  //  slave_out.write(Controller_Slave_Y_SLAVE);
    acc = Controller_Slave_Y_ACC;
    brake = Controller_Slave_Y_BRAKE;
    led_B = !Controller_Slave_Y_LED_BLUE;         // negate because 1 -> led off
    led_R = !Controller_Slave_Y_LED_RED;
    led_G = !Controller_Slave_Y_LED_GREEN;
//   pc.printf("blue: %d \n", Controller_Slave_Y_LED_BLUE);    // Call read_cm() to get the distance in cm
//   pc.printf("red: %d \n", Controller_Slave_Y_LED_RED);
//   pc.printf("slave out: %d \n", Controller_Slave_Y_SLAVE);
//   pc.printf("master in: %d \n", Controller_Slave_U_Master);
//   pc.printf("brake: %d \n", Controller_Slave_Y_BRAKE);
//    pc.printf("green: %d \n", Controller_Slave_Y_LED_GREEN);
//   pc.printf("acc: %d \n", Controller_Slave_Y_ACC);

}

void rt_OneStep(RT_MODEL_Controller_Slave_T *const Controller_Slave_M)
{
    static boolean_T OverrunFlag = false;

    /* Disable interrupts here */

    /* Check for overrun */
    if (OverrunFlag) {
        rtmSetErrorStatus(Controller_Slave_M, "Overrun");
        return;
    }

    OverrunFlag = true;

    /* Save FPU context here (if necessary) */
    /* Re-enable timer or interrupt here */
    /* Set model inputs here */

    /* Step the model */
    Controller_Slave_step(Controller_Slave_M, Controller_Slave_U_V,
                          Controller_Slave_U_D_S, Controller_Slave_U_Master,
                          Controller_Slave_U_QA_EN, &Controller_Slave_Y_BRAKE,
                          &Controller_Slave_Y_ACC, &Controller_Slave_Y_LED_RED,
                          &Controller_Slave_Y_LED_GREEN,
                          &Controller_Slave_Y_LED_BLUE, &Controller_Slave_Y_SLAVE);

    /* Get model outputs here */

    /* Indicate task complete */
    OverrunFlag = false;

    /* Disable interrupts here */
    /* Restore FPU context here (if necessary) */
    /* Enable interrupts here */
}