Diff: main.cpp

Revision:

2:fb694fb2ef9b

Parent:

1:8cb509a319e5

Child:

3:06075cbd49bd

Child:

6:d0717be58ca3

--- a/main.cpp	Fri Jun 03 07:50:12 2016 +0000
+++ b/main.cpp	Wed Jul 06 09:17:23 2016 +0000
@@ -1,122 +1,168 @@
-/*
-* An example showing how to use the Ultrasonic library
-*/
-#include "mbed.h"
-#include "Ultrasonic.h"
-
-extern "C" {
-#include "Controller.h"
-#include "rtwtypes.h"
-}
-
-static RT_MODEL_Controller_T Controller_M_;
-static RT_MODEL_Controller_T *const Controller_M = &Controller_M_;/* Real-time model */
-static B_Controller_T Controller_B;    /* Observable signals */
-static DW_Controller_T Controller_DW;  /* Observable states */
-
-/* '<Root>/V' */
-static real_T Controller_U_V;
-
-/* '<Root>/D_M' */
-static real_T Controller_U_D_M;
-
-/* '<Root>/SLAVE' */
-static uint8_T Controller_U_SLAVE;
-
-/* '<Root>/BRAKE' */
-static uint8_T Controller_Y_BRAKE;
-
-/* '<Root>/LED_BLUE' */
-static uint8_T Controller_Y_LED_BLUE;
-
-/* '<Root>/LED_RED' */
-static uint8_T Controller_Y_LED_RED;
-
-/* '<Root>/MASTER' */
-static uint8_T Controller_Y_MASTER;
-
-/*
- * 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(RT_MODEL_Controller_T *const Controller_M);
-
-Serial  pc(USBTX, USBRX); // tx, rx
-DigitalOut led_R(LED_RED);
-DigitalOut led_B(LED_BLUE);
-DigitalIn  slave(D6);
-Ticker t;
-float V = 50;
-
-
-void step();
-
-int main()
-{
-    /* Pack model data into RTM */
-    Controller_M->ModelData.blockIO = &Controller_B;
-    Controller_M->ModelData.dwork = &Controller_DW;
-
-    /* Initialize model */
-    Controller_initialize(Controller_M, &Controller_U_V, &Controller_U_D_M,
-                          &Controller_U_SLAVE, &Controller_Y_BRAKE,
-                          &Controller_Y_LED_BLUE, &Controller_Y_LED_RED,
-                          &Controller_Y_MASTER);
-    Ultrasonic_init();  // Just call this funtion to initialize the ultrasonic sensor
-    t.attach(&step,0.2);
-    while (true) {
-        wait(0.2);
-    }
-}
-
-
-void step()
-{
-    Controller_U_D_M = read_cm();
-    Controller_U_SLAVE = slave.read();
-    rt_OneStep(Controller_M); 
-    pc.printf("Distance: %f \n", Controller_U_D_M);    // Call read_cm() to get the distance in cm
-    led_B = Controller_Y_LED_BLUE;
-    led_R = Controller_Y_LED_RED;
-}
-
-void rt_OneStep(RT_MODEL_Controller_T *const Controller_M)
-{
-    static boolean_T OverrunFlag = false;
-
-    /* Disable interrupts here */
-
-    /* Check for overrun */
-    if (OverrunFlag) {
-        rtmSetErrorStatus(Controller_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_step(Controller_M, Controller_U_V, Controller_U_D_M,
-                    Controller_U_SLAVE, &Controller_Y_BRAKE,
-                    &Controller_Y_LED_BLUE, &Controller_Y_LED_RED,
-                    &Controller_Y_MASTER);
-
-    /* Get model outputs here */
-
-    /* Indicate task complete */
-    OverrunFlag = false;
-
-    /* Disable interrupts here */
-    /* Restore FPU context here (if necessary) */
-    /* Enable interrupts here */
-}
\ No newline at end of file
+#include "mbed.h"
+#include "Ultrasonic.h"
+
+extern "C" {
+#include "Controller_Master.h"         /* Model's header file */
+#include "rtwtypes.h"
+}
+
+static RT_MODEL_Controller_Master_T Controller_Master_M_;
+static RT_MODEL_Controller_Master_T *const Controller_Master_M =
+    &Controller_Master_M_;               /* Real-time model */
+static B_Controller_Master_T Controller_Master_B;/* Observable signals */
+static DW_Controller_Master_T Controller_Master_DW;/* Observable states */
+
+/* '<Root>/V' */
+static real_T Controller_Master_U_V;
+
+/* '<Root>/D_M' */
+static real_T Controller_Master_U_D_M;
+
+/* '<Root>/SLAVE' */
+static uint8_T Controller_Master_U_Slave;
+
+/* '<Root>/QA_EN' */
+static boolean_T Controller_Master_U_QA_EN;
+
+/* '<Root>/BRAKE' */
+static uint8_T Controller_Master_Y_BRAKE;
+
+/* '<Root>/ACC' */
+static uint8_T Controller_Master_Y_ACC;
+
+/* '<Root>/LED_RED' */
+static uint8_T Controller_Master_Y_LED_RED;
+
+/* '<Root>/LED_GREEN' */
+static uint8_T Controller_Master_Y_LED_GREEN;
+
+/* '<Root>/LED_BLUE' */
+static uint8_T Controller_Master_Y_LED_BLUE;
+
+/* '<Root>/MASTER' */
+static uint8_T Controller_Master_Y_MASTER;
+
+/*
+ * 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(RT_MODEL_Controller_Master_T *const Controller_Master_M);
+void step();
+
+
+Ultrasonic sonic(D2,D4);  // 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);
+DigitalOut master_out(D8);
+DigitalIn  slave(D6);
+float V = 29;   // Set the vehicle speed here
+Ticker t;
+Serial  pc(USBTX, USBRX); // tx, rx
+
+int main()
+{
+    /* Pack model data into RTM */
+    Controller_Master_M->ModelData.blockIO = &Controller_Master_B;
+    Controller_Master_M->ModelData.dwork = &Controller_Master_DW;
+
+
+    Controller_Master_U_V = V;
+    Controller_Master_U_D_M = 50;
+    Controller_Master_U_Slave = 1;
+    Controller_Master_U_QA_EN = true;
+
+    /* Initialize model */
+    Controller_Master_initialize(Controller_Master_M, &Controller_Master_U_V,
+                                 &Controller_Master_U_D_M, &Controller_Master_U_Slave,
+                                 &Controller_Master_U_QA_EN, &Controller_Master_Y_BRAKE,
+                                 &Controller_Master_Y_ACC, &Controller_Master_Y_LED_RED,
+                                 &Controller_Master_Y_LED_GREEN, &Controller_Master_Y_LED_BLUE,
+                                 &Controller_Master_Y_MASTER);
+
+  /* Attach rt_OneStep to a timer or interrupt service routine with
+   * period 0.1 seconds (the model's base sample time) here.  The
+   * call syntax for rt_OneStep is
+   *
+   *  rt_OneStep(Controller_Master_M);
+   */
+    t.attach(&step,0.1);
+    led_B.write(1);
+    led_G.write(1);
+    led_R.write(1);
+    slave.mode(PullDown);
+    master_out.write(1);
+    while (true) {
+        wait(0.2);
+        //led_R= !led_R;
+
+    }
+
+    /* Disable rt_OneStep() here */
+
+    /* Terminate model */
+    Controller_Master_terminate(Controller_Master_M);
+}
+
+void step()
+{
+    Controller_Master_U_V = V;
+    Controller_Master_U_D_M = sonic.read_cm();
+    Controller_Master_U_Slave = slave.read();
+    Controller_Master_U_QA_EN = true;
+    rt_OneStep(Controller_Master_M);
+    master_out.write(Controller_Master_Y_MASTER);
+    pc.printf("blue: %d \n", Controller_Master_Y_LED_BLUE);    // Call read_cm() to get the distance in cm
+    pc.printf("red: %d \n", Controller_Master_Y_LED_RED);
+    pc.printf("master: %d \n", Controller_Master_Y_MASTER);
+    pc.printf("brake: %d \n", Controller_Master_Y_BRAKE);
+    pc.printf("green: %d \n", Controller_Master_Y_LED_GREEN);
+    pc.printf("acc: %d \n", Controller_Master_Y_ACC);
+    led_B = !Controller_Master_Y_LED_BLUE;         // negate because 1 -> led off
+    led_R = !Controller_Master_Y_LED_RED;
+    led_G = !Controller_Master_Y_LED_GREEN;
+}
+
+void rt_OneStep(RT_MODEL_Controller_Master_T *const Controller_Master_M)
+{
+    static boolean_T OverrunFlag = false;
+
+    /* Disable interrupts here */
+
+    /* Check for overrun */
+    if (OverrunFlag) {
+        rtmSetErrorStatus(Controller_Master_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_Master_step(Controller_Master_M, Controller_Master_U_V,
+                           Controller_Master_U_D_M, Controller_Master_U_QA_EN,
+                           &Controller_Master_Y_BRAKE, &Controller_Master_Y_ACC,
+                           &Controller_Master_Y_LED_RED, &Controller_Master_Y_LED_GREEN,
+                           &Controller_Master_Y_LED_BLUE, &Controller_Master_Y_MASTER);
+
+    /* Get model outputs here */
+
+    /* Indicate task complete */
+    OverrunFlag = false;
+
+    /* Disable interrupts here */
+    /* Restore FPU context here (if necessary) */
+    /* Enable interrupts here */
+}