File content as of revision 2:5811e080f41d:

#include "mbed.h"

#include "rtwtypes.h"
#include "serialdata.h"
#include "CircularBuffer.h"

DigitalOut red(LED_RED);
DigitalOut green(LED_GREEN);
DigitalOut blue(LED_BLUE);

DigitalOut      trigger(D2);
InterruptIn     echo(D4);
Timer           t;
Ticker          scheduler;

volatile float           distance;
float fault = 0;

Serial  pc(USBTX, USBRX); // tx, rx


// 
// Copy from ert_main.c
//

#include <stddef.h>
#include <stdio.h>                     /* This ert_main.c example uses printf/fflush */
#include "AEB0.h"                      /* Model's header file */
#include "rtwtypes.h"

/*
 * Associating rt_OneStep with a real-time clock or interrupt service routine
 * is what makes the generated code "real-time".  The function rt_OneStep is
 * always associated with the base rate of the model.  Subrates are managed
 * by the base rate from inside the generated code.  Enabling/disabling
 * interrupts and floating point context switches are target specific.  This
 * example code indicates where these should take place relative to executing
 * the generated code step function.  Overrun behavior should be tailored to
 * your application needs.  This example simply sets an error status in the
 * real-time model and returns from rt_OneStep.
 */
void rt_OneStep(void);
void rt_OneStep(void)
{
  static boolean_T OverrunFlag = false;

  /* Disable interrupts here */

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

  OverrunFlag = true;

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

  /* Step the model */
  AEB0_step();

  /* Get model outputs here */

  /* Indicate task complete */
  OverrunFlag = false;

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

  
//
// End copy
//


    
void    start( void )
{
    t.start();
}

CircularBuffer distanceCircularBuffer(5);

float sensDist = 1;

void stop( void )
{
    t.stop();
    float distance_cm = t.read_us() * 343/20000;
    if(distance_cm > 50) {
        distance_cm = 50;
    }
    //distanceCircularBuffer.push_back(distance_cm);
    sensDist = distance_cm;
    t.reset();
}

 
extern ExtU_AEB0_T AEB0_U;
extern ExtY_AEB0_T AEB0_Y;

enum color {
    NONE, RED, GREEN, BLUE
};

enum {
    LED_OFF = 1,
    LED_ON = 0
};

void setColor(color c) {
    red = LED_OFF;
    blue = LED_OFF;
    green = LED_OFF;
    
    switch(c) {
        case NONE:
            break;
        case RED:
            red = LED_ON;
            break;
        case BLUE:
            blue = LED_ON;
            break;
        case GREEN:
            green = LED_ON;
            break;
    }
}



float brake; 

    
void    do_step( void )
{
    AEB0_U.speed_km_h = serialRecv();
    AEB0_U.distance_m = sensDist;    
 
    rt_OneStep();
    brake = AEB0_Y.brake;
    if(brake > 0) {
        setColor(BLUE);
    } else {
        setColor(NONE);
    }

    fault = AEB0_Y.fault;
    if(fault) {
        setColor(RED);
    }
    float data[3] = {brake, sensDist, fault};
    serialSendVec(data, 3);
}


int main()
{
    
    AEB0_initialize();
  
    scheduler.attach( &do_step, 0.1 );
    
    setColor(NONE);
    
    t.reset();
    echo.rise( &start );
    echo.fall( &stop );

    trigger = 0;
      
    while (true) {
      //  pc.printf( "Reading inputs....\n\r" );


        trigger = 1;
        wait_us( 10 );
        trigger = 0;


    }
    
    AEB0_terminate();
    return 0;
}