diff --git a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/CITSFrame.java b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/CITSFrame.java
new file mode 100644
index 0000000..e8ff5de
--- /dev/null
+++ b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/CITSFrame.java
@@ -0,0 +1,414 @@
+/**
+ *  Copyright (c)2020 CEA LIST, Committer Name, and others.
+ * 
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ * 
+ *  SPDX-License-Identifier: EPL-2.0
+ * 
+ *  Contributors:
+ *  CEA LIST - Initial API and implementation
+ *  Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
+ *  Patrick Tessier (CEA LIST) Patrick.tessier@cea.fr 
+ * 
+ */
+package org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign;
+
+
+/**
+ * <!-- begin-user-doc -->
+ * A representation of the model object '<em><b>CITS Frame</b></em>'.
+ * <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getTime <em>Time</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getVehicleID <em>Vehicle ID</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLatitude <em>Latitude</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLongitude <em>Longitude</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getSpeedValue <em>Speed Value</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getHeadingValue <em>Heading Value</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isBrakePedalEngaged <em>Brake Pedal Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isGasPedalEngaged <em>Gas Pedal Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isEmergencyBrakeEngaged <em>Emergency Brake Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCollisionWarningEngaged <em>Collision Warning Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isAccEngaged <em>Acc Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCruiseControlEngaged <em>Cruise Control Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isSpeedLimiterEngaged <em>Speed Limiter Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getCertificateID <em>Certificate ID</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame()
+ * @model
+ * @generated
+ */
+public interface CITSFrame extends Data {
+	/**
+	 * Returns the value of the '<em><b>Time</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Time</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Time</em>' attribute.
+	 * @see #setTime(double)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_Time()
+	 * @model dataType="org.eclipse.uml2.types.Real" ordered="false"
+	 * @generated
+	 */
+	double getTime();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getTime <em>Time</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Time</em>' attribute.
+	 * @see #getTime()
+	 * @generated
+	 */
+	void setTime(double value);
+
+	/**
+	 * Returns the value of the '<em><b>Vehicle ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Vehicle ID</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Vehicle ID</em>' attribute.
+	 * @see #setVehicleID(double)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_VehicleID()
+	 * @model dataType="org.eclipse.uml2.types.Real" ordered="false"
+	 * @generated
+	 */
+	double getVehicleID();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getVehicleID <em>Vehicle ID</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Vehicle ID</em>' attribute.
+	 * @see #getVehicleID()
+	 * @generated
+	 */
+	void setVehicleID(double value);
+
+	/**
+	 * Returns the value of the '<em><b>Latitude</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Latitude</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Latitude</em>' attribute.
+	 * @see #setLatitude(double)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_Latitude()
+	 * @model dataType="org.eclipse.uml2.types.Real" ordered="false"
+	 * @generated
+	 */
+	double getLatitude();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLatitude <em>Latitude</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Latitude</em>' attribute.
+	 * @see #getLatitude()
+	 * @generated
+	 */
+	void setLatitude(double value);
+
+	/**
+	 * Returns the value of the '<em><b>Longitude</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Longitude</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Longitude</em>' attribute.
+	 * @see #setLongitude(double)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_Longitude()
+	 * @model dataType="org.eclipse.uml2.types.Real" ordered="false"
+	 * @generated
+	 */
+	double getLongitude();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLongitude <em>Longitude</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Longitude</em>' attribute.
+	 * @see #getLongitude()
+	 * @generated
+	 */
+	void setLongitude(double value);
+
+	/**
+	 * Returns the value of the '<em><b>Speed Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Speed Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Speed Value</em>' attribute.
+	 * @see #setSpeedValue(double)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_SpeedValue()
+	 * @model dataType="org.eclipse.uml2.types.Real" ordered="false"
+	 * @generated
+	 */
+	double getSpeedValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getSpeedValue <em>Speed Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Speed Value</em>' attribute.
+	 * @see #getSpeedValue()
+	 * @generated
+	 */
+	void setSpeedValue(double value);
+
+	/**
+	 * Returns the value of the '<em><b>Heading Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Heading Value</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Heading Value</em>' attribute.
+	 * @see #setHeadingValue(double)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_HeadingValue()
+	 * @model dataType="org.eclipse.uml2.types.Real" ordered="false"
+	 * @generated
+	 */
+	double getHeadingValue();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getHeadingValue <em>Heading Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Heading Value</em>' attribute.
+	 * @see #getHeadingValue()
+	 * @generated
+	 */
+	void setHeadingValue(double value);
+
+	/**
+	 * Returns the value of the '<em><b>Brake Pedal Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Brake Pedal Engaged</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Brake Pedal Engaged</em>' attribute.
+	 * @see #setBrakePedalEngaged(boolean)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_BrakePedalEngaged()
+	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
+	 * @generated
+	 */
+	boolean isBrakePedalEngaged();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isBrakePedalEngaged <em>Brake Pedal Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Brake Pedal Engaged</em>' attribute.
+	 * @see #isBrakePedalEngaged()
+	 * @generated
+	 */
+	void setBrakePedalEngaged(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Gas Pedal Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Gas Pedal Engaged</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Gas Pedal Engaged</em>' attribute.
+	 * @see #setGasPedalEngaged(boolean)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_GasPedalEngaged()
+	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
+	 * @generated
+	 */
+	boolean isGasPedalEngaged();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isGasPedalEngaged <em>Gas Pedal Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Gas Pedal Engaged</em>' attribute.
+	 * @see #isGasPedalEngaged()
+	 * @generated
+	 */
+	void setGasPedalEngaged(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Emergency Brake Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Emergency Brake Engaged</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Emergency Brake Engaged</em>' attribute.
+	 * @see #setEmergencyBrakeEngaged(boolean)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_EmergencyBrakeEngaged()
+	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
+	 * @generated
+	 */
+	boolean isEmergencyBrakeEngaged();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isEmergencyBrakeEngaged <em>Emergency Brake Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Emergency Brake Engaged</em>' attribute.
+	 * @see #isEmergencyBrakeEngaged()
+	 * @generated
+	 */
+	void setEmergencyBrakeEngaged(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Collision Warning Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Collision Warning Engaged</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Collision Warning Engaged</em>' attribute.
+	 * @see #setCollisionWarningEngaged(boolean)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_CollisionWarningEngaged()
+	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
+	 * @generated
+	 */
+	boolean isCollisionWarningEngaged();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCollisionWarningEngaged <em>Collision Warning Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Collision Warning Engaged</em>' attribute.
+	 * @see #isCollisionWarningEngaged()
+	 * @generated
+	 */
+	void setCollisionWarningEngaged(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Acc Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Acc Engaged</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Acc Engaged</em>' attribute.
+	 * @see #setAccEngaged(boolean)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_AccEngaged()
+	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
+	 * @generated
+	 */
+	boolean isAccEngaged();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isAccEngaged <em>Acc Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Acc Engaged</em>' attribute.
+	 * @see #isAccEngaged()
+	 * @generated
+	 */
+	void setAccEngaged(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Cruise Control Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Cruise Control Engaged</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Cruise Control Engaged</em>' attribute.
+	 * @see #setCruiseControlEngaged(boolean)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_CruiseControlEngaged()
+	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
+	 * @generated
+	 */
+	boolean isCruiseControlEngaged();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCruiseControlEngaged <em>Cruise Control Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Cruise Control Engaged</em>' attribute.
+	 * @see #isCruiseControlEngaged()
+	 * @generated
+	 */
+	void setCruiseControlEngaged(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Speed Limiter Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Speed Limiter Engaged</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Speed Limiter Engaged</em>' attribute.
+	 * @see #setSpeedLimiterEngaged(boolean)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_SpeedLimiterEngaged()
+	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
+	 * @generated
+	 */
+	boolean isSpeedLimiterEngaged();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isSpeedLimiterEngaged <em>Speed Limiter Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Speed Limiter Engaged</em>' attribute.
+	 * @see #isSpeedLimiterEngaged()
+	 * @generated
+	 */
+	void setSpeedLimiterEngaged(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Certificate ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Certificate ID</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Certificate ID</em>' attribute.
+	 * @see #setCertificateID(String)
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage#getCITSFrame_CertificateID()
+	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
+	 * @generated
+	 */
+	String getCertificateID();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getCertificateID <em>Certificate ID</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Certificate ID</em>' attribute.
+	 * @see #getCertificateID()
+	 * @generated
+	 */
+	void setCertificateID(String value);
+
+} // CITSFrame
diff --git a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/impl/CITSFrameImpl.java b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/impl/CITSFrameImpl.java
new file mode 100644
index 0000000..2be1018
--- /dev/null
+++ b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/impl/CITSFrameImpl.java
@@ -0,0 +1,906 @@
+/**
+ *  Copyright (c)2020 CEA LIST, Committer Name, and others.
+ * 
+ *  All rights reserved. This program and the accompanying materials
+ *  are made available under the terms of the Eclipse Public License 2.0
+ *  which accompanies this distribution, and is available at
+ *  https://www.eclipse.org/legal/epl-2.0/
+ * 
+ *  SPDX-License-Identifier: EPL-2.0
+ * 
+ *  Contributors:
+ *  CEA LIST - Initial API and implementation
+ *  Gabriel Pedroza (CEA LIST) gabriel.pedroza@cea.fr
+ *  Patrick Tessier (CEA LIST) Patrick.tessier@cea.fr 
+ * 
+ */
+package org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+
+import org.eclipse.emf.ecore.EClass;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+
+import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame;
+import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.pdp4engDesignPackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model object '<em><b>CITS Frame</b></em>'.
+ * <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#getTime <em>Time</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#getVehicleID <em>Vehicle ID</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#getLatitude <em>Latitude</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#getLongitude <em>Longitude</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#getSpeedValue <em>Speed Value</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#getHeadingValue <em>Heading Value</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#isBrakePedalEngaged <em>Brake Pedal Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#isGasPedalEngaged <em>Gas Pedal Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#isEmergencyBrakeEngaged <em>Emergency Brake Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#isCollisionWarningEngaged <em>Collision Warning Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#isAccEngaged <em>Acc Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#isCruiseControlEngaged <em>Cruise Control Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#isSpeedLimiterEngaged <em>Speed Limiter Engaged</em>}</li>
+ *   <li>{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl#getCertificateID <em>Certificate ID</em>}</li>
+ * </ul>
+ *
+ * @generated
+ */
+public class CITSFrameImpl extends DataImpl implements CITSFrame {
+	/**
+	 * The default value of the '{@link #getTime() <em>Time</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTime()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double TIME_EDEFAULT = 0.0;
+
+	/**
+	 * The cached value of the '{@link #getTime() <em>Time</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getTime()
+	 * @generated
+	 * @ordered
+	 */
+	protected double time = TIME_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getVehicleID() <em>Vehicle ID</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getVehicleID()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double VEHICLE_ID_EDEFAULT = 0.0;
+
+	/**
+	 * The cached value of the '{@link #getVehicleID() <em>Vehicle ID</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getVehicleID()
+	 * @generated
+	 * @ordered
+	 */
+	protected double vehicleID = VEHICLE_ID_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getLatitude() <em>Latitude</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLatitude()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double LATITUDE_EDEFAULT = 0.0;
+
+	/**
+	 * The cached value of the '{@link #getLatitude() <em>Latitude</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLatitude()
+	 * @generated
+	 * @ordered
+	 */
+	protected double latitude = LATITUDE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getLongitude() <em>Longitude</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLongitude()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double LONGITUDE_EDEFAULT = 0.0;
+
+	/**
+	 * The cached value of the '{@link #getLongitude() <em>Longitude</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getLongitude()
+	 * @generated
+	 * @ordered
+	 */
+	protected double longitude = LONGITUDE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getSpeedValue() <em>Speed Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSpeedValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double SPEED_VALUE_EDEFAULT = 0.0;
+
+	/**
+	 * The cached value of the '{@link #getSpeedValue() <em>Speed Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getSpeedValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected double speedValue = SPEED_VALUE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getHeadingValue() <em>Heading Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getHeadingValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final double HEADING_VALUE_EDEFAULT = 0.0;
+
+	/**
+	 * The cached value of the '{@link #getHeadingValue() <em>Heading Value</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getHeadingValue()
+	 * @generated
+	 * @ordered
+	 */
+	protected double headingValue = HEADING_VALUE_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isBrakePedalEngaged() <em>Brake Pedal Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isBrakePedalEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean BRAKE_PEDAL_ENGAGED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isBrakePedalEngaged() <em>Brake Pedal Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isBrakePedalEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean brakePedalEngaged = BRAKE_PEDAL_ENGAGED_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isGasPedalEngaged() <em>Gas Pedal Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isGasPedalEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean GAS_PEDAL_ENGAGED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isGasPedalEngaged() <em>Gas Pedal Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isGasPedalEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean gasPedalEngaged = GAS_PEDAL_ENGAGED_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isEmergencyBrakeEngaged() <em>Emergency Brake Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isEmergencyBrakeEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean EMERGENCY_BRAKE_ENGAGED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isEmergencyBrakeEngaged() <em>Emergency Brake Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isEmergencyBrakeEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean emergencyBrakeEngaged = EMERGENCY_BRAKE_ENGAGED_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isCollisionWarningEngaged() <em>Collision Warning Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isCollisionWarningEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean COLLISION_WARNING_ENGAGED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isCollisionWarningEngaged() <em>Collision Warning Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isCollisionWarningEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean collisionWarningEngaged = COLLISION_WARNING_ENGAGED_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isAccEngaged() <em>Acc Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isAccEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean ACC_ENGAGED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isAccEngaged() <em>Acc Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isAccEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean accEngaged = ACC_ENGAGED_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isCruiseControlEngaged() <em>Cruise Control Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isCruiseControlEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean CRUISE_CONTROL_ENGAGED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isCruiseControlEngaged() <em>Cruise Control Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isCruiseControlEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean cruiseControlEngaged = CRUISE_CONTROL_ENGAGED_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #isSpeedLimiterEngaged() <em>Speed Limiter Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSpeedLimiterEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean SPEED_LIMITER_ENGAGED_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isSpeedLimiterEngaged() <em>Speed Limiter Engaged</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #isSpeedLimiterEngaged()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean speedLimiterEngaged = SPEED_LIMITER_ENGAGED_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getCertificateID() <em>Certificate ID</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCertificateID()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String CERTIFICATE_ID_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getCertificateID() <em>Certificate ID</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getCertificateID()
+	 * @generated
+	 * @ordered
+	 */
+	protected String certificateID = CERTIFICATE_ID_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected CITSFrameImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return pdp4engDesignPackage.Literals.CITS_FRAME;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public double getTime() {
+		return time;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setTime(double newTime) {
+		double oldTime = time;
+		time = newTime;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__TIME, oldTime, time));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public double getVehicleID() {
+		return vehicleID;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setVehicleID(double newVehicleID) {
+		double oldVehicleID = vehicleID;
+		vehicleID = newVehicleID;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__VEHICLE_ID, oldVehicleID, vehicleID));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public double getLatitude() {
+		return latitude;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setLatitude(double newLatitude) {
+		double oldLatitude = latitude;
+		latitude = newLatitude;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__LATITUDE, oldLatitude, latitude));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public double getLongitude() {
+		return longitude;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setLongitude(double newLongitude) {
+		double oldLongitude = longitude;
+		longitude = newLongitude;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__LONGITUDE, oldLongitude, longitude));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public double getSpeedValue() {
+		return speedValue;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setSpeedValue(double newSpeedValue) {
+		double oldSpeedValue = speedValue;
+		speedValue = newSpeedValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__SPEED_VALUE, oldSpeedValue, speedValue));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public double getHeadingValue() {
+		return headingValue;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setHeadingValue(double newHeadingValue) {
+		double oldHeadingValue = headingValue;
+		headingValue = newHeadingValue;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__HEADING_VALUE, oldHeadingValue, headingValue));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isBrakePedalEngaged() {
+		return brakePedalEngaged;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setBrakePedalEngaged(boolean newBrakePedalEngaged) {
+		boolean oldBrakePedalEngaged = brakePedalEngaged;
+		brakePedalEngaged = newBrakePedalEngaged;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__BRAKE_PEDAL_ENGAGED, oldBrakePedalEngaged, brakePedalEngaged));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isGasPedalEngaged() {
+		return gasPedalEngaged;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setGasPedalEngaged(boolean newGasPedalEngaged) {
+		boolean oldGasPedalEngaged = gasPedalEngaged;
+		gasPedalEngaged = newGasPedalEngaged;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__GAS_PEDAL_ENGAGED, oldGasPedalEngaged, gasPedalEngaged));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isEmergencyBrakeEngaged() {
+		return emergencyBrakeEngaged;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setEmergencyBrakeEngaged(boolean newEmergencyBrakeEngaged) {
+		boolean oldEmergencyBrakeEngaged = emergencyBrakeEngaged;
+		emergencyBrakeEngaged = newEmergencyBrakeEngaged;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__EMERGENCY_BRAKE_ENGAGED, oldEmergencyBrakeEngaged, emergencyBrakeEngaged));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isCollisionWarningEngaged() {
+		return collisionWarningEngaged;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setCollisionWarningEngaged(boolean newCollisionWarningEngaged) {
+		boolean oldCollisionWarningEngaged = collisionWarningEngaged;
+		collisionWarningEngaged = newCollisionWarningEngaged;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__COLLISION_WARNING_ENGAGED, oldCollisionWarningEngaged, collisionWarningEngaged));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isAccEngaged() {
+		return accEngaged;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setAccEngaged(boolean newAccEngaged) {
+		boolean oldAccEngaged = accEngaged;
+		accEngaged = newAccEngaged;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__ACC_ENGAGED, oldAccEngaged, accEngaged));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isCruiseControlEngaged() {
+		return cruiseControlEngaged;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setCruiseControlEngaged(boolean newCruiseControlEngaged) {
+		boolean oldCruiseControlEngaged = cruiseControlEngaged;
+		cruiseControlEngaged = newCruiseControlEngaged;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__CRUISE_CONTROL_ENGAGED, oldCruiseControlEngaged, cruiseControlEngaged));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean isSpeedLimiterEngaged() {
+		return speedLimiterEngaged;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setSpeedLimiterEngaged(boolean newSpeedLimiterEngaged) {
+		boolean oldSpeedLimiterEngaged = speedLimiterEngaged;
+		speedLimiterEngaged = newSpeedLimiterEngaged;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__SPEED_LIMITER_ENGAGED, oldSpeedLimiterEngaged, speedLimiterEngaged));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String getCertificateID() {
+		return certificateID;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void setCertificateID(String newCertificateID) {
+		String oldCertificateID = certificateID;
+		certificateID = newCertificateID;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, pdp4engDesignPackage.CITS_FRAME__CERTIFICATE_ID, oldCertificateID, certificateID));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+			case pdp4engDesignPackage.CITS_FRAME__TIME:
+				return getTime();
+			case pdp4engDesignPackage.CITS_FRAME__VEHICLE_ID:
+				return getVehicleID();
+			case pdp4engDesignPackage.CITS_FRAME__LATITUDE:
+				return getLatitude();
+			case pdp4engDesignPackage.CITS_FRAME__LONGITUDE:
+				return getLongitude();
+			case pdp4engDesignPackage.CITS_FRAME__SPEED_VALUE:
+				return getSpeedValue();
+			case pdp4engDesignPackage.CITS_FRAME__HEADING_VALUE:
+				return getHeadingValue();
+			case pdp4engDesignPackage.CITS_FRAME__BRAKE_PEDAL_ENGAGED:
+				return isBrakePedalEngaged();
+			case pdp4engDesignPackage.CITS_FRAME__GAS_PEDAL_ENGAGED:
+				return isGasPedalEngaged();
+			case pdp4engDesignPackage.CITS_FRAME__EMERGENCY_BRAKE_ENGAGED:
+				return isEmergencyBrakeEngaged();
+			case pdp4engDesignPackage.CITS_FRAME__COLLISION_WARNING_ENGAGED:
+				return isCollisionWarningEngaged();
+			case pdp4engDesignPackage.CITS_FRAME__ACC_ENGAGED:
+				return isAccEngaged();
+			case pdp4engDesignPackage.CITS_FRAME__CRUISE_CONTROL_ENGAGED:
+				return isCruiseControlEngaged();
+			case pdp4engDesignPackage.CITS_FRAME__SPEED_LIMITER_ENGAGED:
+				return isSpeedLimiterEngaged();
+			case pdp4engDesignPackage.CITS_FRAME__CERTIFICATE_ID:
+				return getCertificateID();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+			case pdp4engDesignPackage.CITS_FRAME__TIME:
+				setTime((Double)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__VEHICLE_ID:
+				setVehicleID((Double)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__LATITUDE:
+				setLatitude((Double)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__LONGITUDE:
+				setLongitude((Double)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__SPEED_VALUE:
+				setSpeedValue((Double)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__HEADING_VALUE:
+				setHeadingValue((Double)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__BRAKE_PEDAL_ENGAGED:
+				setBrakePedalEngaged((Boolean)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__GAS_PEDAL_ENGAGED:
+				setGasPedalEngaged((Boolean)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__EMERGENCY_BRAKE_ENGAGED:
+				setEmergencyBrakeEngaged((Boolean)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__COLLISION_WARNING_ENGAGED:
+				setCollisionWarningEngaged((Boolean)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__ACC_ENGAGED:
+				setAccEngaged((Boolean)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__CRUISE_CONTROL_ENGAGED:
+				setCruiseControlEngaged((Boolean)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__SPEED_LIMITER_ENGAGED:
+				setSpeedLimiterEngaged((Boolean)newValue);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__CERTIFICATE_ID:
+				setCertificateID((String)newValue);
+				return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+			case pdp4engDesignPackage.CITS_FRAME__TIME:
+				setTime(TIME_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__VEHICLE_ID:
+				setVehicleID(VEHICLE_ID_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__LATITUDE:
+				setLatitude(LATITUDE_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__LONGITUDE:
+				setLongitude(LONGITUDE_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__SPEED_VALUE:
+				setSpeedValue(SPEED_VALUE_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__HEADING_VALUE:
+				setHeadingValue(HEADING_VALUE_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__BRAKE_PEDAL_ENGAGED:
+				setBrakePedalEngaged(BRAKE_PEDAL_ENGAGED_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__GAS_PEDAL_ENGAGED:
+				setGasPedalEngaged(GAS_PEDAL_ENGAGED_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__EMERGENCY_BRAKE_ENGAGED:
+				setEmergencyBrakeEngaged(EMERGENCY_BRAKE_ENGAGED_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__COLLISION_WARNING_ENGAGED:
+				setCollisionWarningEngaged(COLLISION_WARNING_ENGAGED_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__ACC_ENGAGED:
+				setAccEngaged(ACC_ENGAGED_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__CRUISE_CONTROL_ENGAGED:
+				setCruiseControlEngaged(CRUISE_CONTROL_ENGAGED_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__SPEED_LIMITER_ENGAGED:
+				setSpeedLimiterEngaged(SPEED_LIMITER_ENGAGED_EDEFAULT);
+				return;
+			case pdp4engDesignPackage.CITS_FRAME__CERTIFICATE_ID:
+				setCertificateID(CERTIFICATE_ID_EDEFAULT);
+				return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+			case pdp4engDesignPackage.CITS_FRAME__TIME:
+				return time != TIME_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__VEHICLE_ID:
+				return vehicleID != VEHICLE_ID_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__LATITUDE:
+				return latitude != LATITUDE_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__LONGITUDE:
+				return longitude != LONGITUDE_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__SPEED_VALUE:
+				return speedValue != SPEED_VALUE_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__HEADING_VALUE:
+				return headingValue != HEADING_VALUE_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__BRAKE_PEDAL_ENGAGED:
+				return brakePedalEngaged != BRAKE_PEDAL_ENGAGED_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__GAS_PEDAL_ENGAGED:
+				return gasPedalEngaged != GAS_PEDAL_ENGAGED_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__EMERGENCY_BRAKE_ENGAGED:
+				return emergencyBrakeEngaged != EMERGENCY_BRAKE_ENGAGED_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__COLLISION_WARNING_ENGAGED:
+				return collisionWarningEngaged != COLLISION_WARNING_ENGAGED_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__ACC_ENGAGED:
+				return accEngaged != ACC_ENGAGED_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__CRUISE_CONTROL_ENGAGED:
+				return cruiseControlEngaged != CRUISE_CONTROL_ENGAGED_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__SPEED_LIMITER_ENGAGED:
+				return speedLimiterEngaged != SPEED_LIMITER_ENGAGED_EDEFAULT;
+			case pdp4engDesignPackage.CITS_FRAME__CERTIFICATE_ID:
+				return CERTIFICATE_ID_EDEFAULT == null ? certificateID != null : !CERTIFICATE_ID_EDEFAULT.equals(certificateID);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy()) return super.toString();
+
+		StringBuilder result = new StringBuilder(super.toString());
+		result.append(" (time: ");
+		result.append(time);
+		result.append(", vehicleID: ");
+		result.append(vehicleID);
+		result.append(", latitude: ");
+		result.append(latitude);
+		result.append(", longitude: ");
+		result.append(longitude);
+		result.append(", speedValue: ");
+		result.append(speedValue);
+		result.append(", headingValue: ");
+		result.append(headingValue);
+		result.append(", brakePedalEngaged: ");
+		result.append(brakePedalEngaged);
+		result.append(", gasPedalEngaged: ");
+		result.append(gasPedalEngaged);
+		result.append(", emergencyBrakeEngaged: ");
+		result.append(emergencyBrakeEngaged);
+		result.append(", collisionWarningEngaged: ");
+		result.append(collisionWarningEngaged);
+		result.append(", accEngaged: ");
+		result.append(accEngaged);
+		result.append(", cruiseControlEngaged: ");
+		result.append(cruiseControlEngaged);
+		result.append(", speedLimiterEngaged: ");
+		result.append(speedLimiterEngaged);
+		result.append(", certificateID: ");
+		result.append(certificateID);
+		result.append(')');
+		return result.toString();
+	}
+
+} //CITSFrameImpl
diff --git a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/impl/pdp4engDesignFactoryImpl.java b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/impl/pdp4engDesignFactoryImpl.java
index 8b2f1e6..0f3038d 100644
--- a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/impl/pdp4engDesignFactoryImpl.java
+++ b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/impl/pdp4engDesignFactoryImpl.java
@@ -24,6 +24,7 @@
 
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
 
+import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CallProcess;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CompositeData;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Data;
@@ -100,6 +101,7 @@
 			case pdp4engDesignPackage.PROCESS: return createProcess();
 			case pdp4engDesignPackage.CALL_PROCESS: return createCallProcess();
 			case pdp4engDesignPackage.SMART_GRID_FRAME: return createSmartGridFrame();
+			case pdp4engDesignPackage.CITS_FRAME: return createCITSFrame();
 			default:
 				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
 		}
@@ -276,6 +278,17 @@
 	 * @generated
 	 */
 	@Override
+	public CITSFrame createCITSFrame() {
+		CITSFrameImpl citsFrame = new CITSFrameImpl();
+		return citsFrame;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
 	public pdp4engDesignPackage getpdp4engDesignPackage() {
 		return (pdp4engDesignPackage)getEPackage();
 	}
diff --git a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/impl/pdp4engDesignPackageImpl.java b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/impl/pdp4engDesignPackageImpl.java
index 3489d04..99d936b 100644
--- a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/impl/pdp4engDesignPackageImpl.java
+++ b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/impl/pdp4engDesignPackageImpl.java
@@ -24,6 +24,7 @@
 
 import org.eclipse.emf.ecore.impl.EPackageImpl;
 
+import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CallProcess;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CompositeData;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Data;
@@ -158,6 +159,13 @@
 	private EClass smartGridFrameEClass = null;
 
 	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass citsFrameEClass = null;
+
+	/**
 	 * Creates an instance of the model <b>Package</b>, registered with
 	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
 	 * package URI value.
@@ -629,6 +637,156 @@
 	 * @generated
 	 */
 	@Override
+	public EClass getCITSFrame() {
+		return citsFrameEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_Time() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_VehicleID() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_Latitude() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(2);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_Longitude() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(3);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_SpeedValue() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_HeadingValue() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(5);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_BrakePedalEngaged() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(6);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_GasPedalEngaged() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(7);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_EmergencyBrakeEngaged() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(8);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_CollisionWarningEngaged() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(9);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_AccEngaged() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(10);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_CruiseControlEngaged() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(11);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_SpeedLimiterEngaged() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(12);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EAttribute getCITSFrame_CertificateID() {
+		return (EAttribute)citsFrameEClass.getEStructuralFeatures().get(13);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
 	public pdp4engDesignFactory getpdp4engDesignFactory() {
 		return (pdp4engDesignFactory)getEFactoryInstance();
 	}
@@ -706,6 +864,22 @@
 		createEAttribute(smartGridFrameEClass, SMART_GRID_FRAME__CONSUMPTION);
 		createEAttribute(smartGridFrameEClass, SMART_GRID_FRAME__CRC);
 		createEAttribute(smartGridFrameEClass, SMART_GRID_FRAME__ID);
+
+		citsFrameEClass = createEClass(CITS_FRAME);
+		createEAttribute(citsFrameEClass, CITS_FRAME__TIME);
+		createEAttribute(citsFrameEClass, CITS_FRAME__VEHICLE_ID);
+		createEAttribute(citsFrameEClass, CITS_FRAME__LATITUDE);
+		createEAttribute(citsFrameEClass, CITS_FRAME__LONGITUDE);
+		createEAttribute(citsFrameEClass, CITS_FRAME__SPEED_VALUE);
+		createEAttribute(citsFrameEClass, CITS_FRAME__HEADING_VALUE);
+		createEAttribute(citsFrameEClass, CITS_FRAME__BRAKE_PEDAL_ENGAGED);
+		createEAttribute(citsFrameEClass, CITS_FRAME__GAS_PEDAL_ENGAGED);
+		createEAttribute(citsFrameEClass, CITS_FRAME__EMERGENCY_BRAKE_ENGAGED);
+		createEAttribute(citsFrameEClass, CITS_FRAME__COLLISION_WARNING_ENGAGED);
+		createEAttribute(citsFrameEClass, CITS_FRAME__ACC_ENGAGED);
+		createEAttribute(citsFrameEClass, CITS_FRAME__CRUISE_CONTROL_ENGAGED);
+		createEAttribute(citsFrameEClass, CITS_FRAME__SPEED_LIMITER_ENGAGED);
+		createEAttribute(citsFrameEClass, CITS_FRAME__CERTIFICATE_ID);
 	}
 
 	/**
@@ -745,6 +919,7 @@
 		compositeDataEClass.getESuperTypes().add(this.getData());
 		tableEClass.getESuperTypes().add(this.getData());
 		smartGridFrameEClass.getESuperTypes().add(this.getData());
+		citsFrameEClass.getESuperTypes().add(this.getData());
 
 		// Initialize classes, features, and operations; add parameters
 		initEClass(opaqueDataEClass, OpaqueData.class, "OpaqueData", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
@@ -802,6 +977,22 @@
 		initEAttribute(getSmartGridFrame_Crc(), theTypesPackage.getString(), "crc", null, 0, 1, SmartGridFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 		initEAttribute(getSmartGridFrame_Id(), theTypesPackage.getString(), "id", null, 0, 1, SmartGridFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
 
+		initEClass(citsFrameEClass, CITSFrame.class, "CITSFrame", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getCITSFrame_Time(), theTypesPackage.getReal(), "time", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_VehicleID(), theTypesPackage.getReal(), "vehicleID", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_Latitude(), theTypesPackage.getReal(), "latitude", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_Longitude(), theTypesPackage.getReal(), "longitude", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_SpeedValue(), theTypesPackage.getReal(), "speedValue", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_HeadingValue(), theTypesPackage.getReal(), "headingValue", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_BrakePedalEngaged(), theTypesPackage.getBoolean(), "brakePedalEngaged", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_GasPedalEngaged(), theTypesPackage.getBoolean(), "gasPedalEngaged", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_EmergencyBrakeEngaged(), theTypesPackage.getBoolean(), "emergencyBrakeEngaged", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_CollisionWarningEngaged(), theTypesPackage.getBoolean(), "collisionWarningEngaged", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_AccEngaged(), theTypesPackage.getBoolean(), "accEngaged", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_CruiseControlEngaged(), theTypesPackage.getBoolean(), "cruiseControlEngaged", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_SpeedLimiterEngaged(), theTypesPackage.getBoolean(), "speedLimiterEngaged", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+		initEAttribute(getCITSFrame_CertificateID(), theTypesPackage.getString(), "certificateID", null, 0, 1, CITSFrame.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, !IS_ORDERED);
+
 		// Create resource
 		createResource(eNS_URI);
 	}
diff --git a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/pdp4engDesignFactory.java b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/pdp4engDesignFactory.java
index 9e5ba3b..744df4f 100644
--- a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/pdp4engDesignFactory.java
+++ b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/pdp4engDesignFactory.java
@@ -171,6 +171,15 @@
 	SmartGridFrame createSmartGridFrame();
 
 	/**
+	 * Returns a new object of class '<em>CITS Frame</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>CITS Frame</em>'.
+	 * @generated
+	 */
+	CITSFrame createCITSFrame();
+
+	/**
 	 * Returns the package supported by this factory.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/pdp4engDesignPackage.java b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/pdp4engDesignPackage.java
index 90de251..a80824e 100644
--- a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/pdp4engDesignPackage.java
+++ b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/pdp4engDesignPackage.java
@@ -762,6 +762,170 @@
 
 
 	/**
+	 * The meta object id for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl <em>CITS Frame</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getCITSFrame()
+	 * @generated
+	 */
+	int CITS_FRAME = 15;
+
+	/**
+	 * The feature id for the '<em><b>Base Class</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__BASE_CLASS = DATA__BASE_CLASS;
+
+	/**
+	 * The feature id for the '<em><b>Time</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__TIME = DATA_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Vehicle ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__VEHICLE_ID = DATA_FEATURE_COUNT + 1;
+
+	/**
+	 * The feature id for the '<em><b>Latitude</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__LATITUDE = DATA_FEATURE_COUNT + 2;
+
+	/**
+	 * The feature id for the '<em><b>Longitude</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__LONGITUDE = DATA_FEATURE_COUNT + 3;
+
+	/**
+	 * The feature id for the '<em><b>Speed Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__SPEED_VALUE = DATA_FEATURE_COUNT + 4;
+
+	/**
+	 * The feature id for the '<em><b>Heading Value</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__HEADING_VALUE = DATA_FEATURE_COUNT + 5;
+
+	/**
+	 * The feature id for the '<em><b>Brake Pedal Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__BRAKE_PEDAL_ENGAGED = DATA_FEATURE_COUNT + 6;
+
+	/**
+	 * The feature id for the '<em><b>Gas Pedal Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__GAS_PEDAL_ENGAGED = DATA_FEATURE_COUNT + 7;
+
+	/**
+	 * The feature id for the '<em><b>Emergency Brake Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__EMERGENCY_BRAKE_ENGAGED = DATA_FEATURE_COUNT + 8;
+
+	/**
+	 * The feature id for the '<em><b>Collision Warning Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__COLLISION_WARNING_ENGAGED = DATA_FEATURE_COUNT + 9;
+
+	/**
+	 * The feature id for the '<em><b>Acc Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__ACC_ENGAGED = DATA_FEATURE_COUNT + 10;
+
+	/**
+	 * The feature id for the '<em><b>Cruise Control Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__CRUISE_CONTROL_ENGAGED = DATA_FEATURE_COUNT + 11;
+
+	/**
+	 * The feature id for the '<em><b>Speed Limiter Engaged</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__SPEED_LIMITER_ENGAGED = DATA_FEATURE_COUNT + 12;
+
+	/**
+	 * The feature id for the '<em><b>Certificate ID</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME__CERTIFICATE_ID = DATA_FEATURE_COUNT + 13;
+
+	/**
+	 * The number of structural features of the '<em>CITS Frame</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME_FEATURE_COUNT = DATA_FEATURE_COUNT + 14;
+
+	/**
+	 * The number of operations of the '<em>CITS Frame</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int CITS_FRAME_OPERATION_COUNT = DATA_OPERATION_COUNT + 0;
+
+
+	/**
 	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.OpaqueData <em>Opaque Data</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1187,6 +1351,170 @@
 	EAttribute getSmartGridFrame_Id();
 
 	/**
+	 * Returns the meta object for class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame <em>CITS Frame</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>CITS Frame</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame
+	 * @generated
+	 */
+	EClass getCITSFrame();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getTime <em>Time</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Time</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getTime()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_Time();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getVehicleID <em>Vehicle ID</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Vehicle ID</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getVehicleID()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_VehicleID();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLatitude <em>Latitude</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Latitude</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLatitude()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_Latitude();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLongitude <em>Longitude</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Longitude</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getLongitude()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_Longitude();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getSpeedValue <em>Speed Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Speed Value</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getSpeedValue()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_SpeedValue();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getHeadingValue <em>Heading Value</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Heading Value</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getHeadingValue()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_HeadingValue();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isBrakePedalEngaged <em>Brake Pedal Engaged</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Brake Pedal Engaged</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isBrakePedalEngaged()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_BrakePedalEngaged();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isGasPedalEngaged <em>Gas Pedal Engaged</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Gas Pedal Engaged</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isGasPedalEngaged()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_GasPedalEngaged();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isEmergencyBrakeEngaged <em>Emergency Brake Engaged</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Emergency Brake Engaged</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isEmergencyBrakeEngaged()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_EmergencyBrakeEngaged();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCollisionWarningEngaged <em>Collision Warning Engaged</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Collision Warning Engaged</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCollisionWarningEngaged()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_CollisionWarningEngaged();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isAccEngaged <em>Acc Engaged</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Acc Engaged</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isAccEngaged()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_AccEngaged();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCruiseControlEngaged <em>Cruise Control Engaged</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Cruise Control Engaged</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isCruiseControlEngaged()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_CruiseControlEngaged();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isSpeedLimiterEngaged <em>Speed Limiter Engaged</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Speed Limiter Engaged</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#isSpeedLimiterEngaged()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_SpeedLimiterEngaged();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getCertificateID <em>Certificate ID</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Certificate ID</em>'.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame#getCertificateID()
+	 * @see #getCITSFrame()
+	 * @generated
+	 */
+	EAttribute getCITSFrame_CertificateID();
+
+	/**
 	 * Returns the factory that creates the instances of the model.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
@@ -1559,6 +1887,128 @@
 		 */
 		EAttribute SMART_GRID_FRAME__ID = eINSTANCE.getSmartGridFrame_Id();
 
+		/**
+		 * The meta object literal for the '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl <em>CITS Frame</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.CITSFrameImpl
+		 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.impl.pdp4engDesignPackageImpl#getCITSFrame()
+		 * @generated
+		 */
+		EClass CITS_FRAME = eINSTANCE.getCITSFrame();
+
+		/**
+		 * The meta object literal for the '<em><b>Time</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__TIME = eINSTANCE.getCITSFrame_Time();
+
+		/**
+		 * The meta object literal for the '<em><b>Vehicle ID</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__VEHICLE_ID = eINSTANCE.getCITSFrame_VehicleID();
+
+		/**
+		 * The meta object literal for the '<em><b>Latitude</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__LATITUDE = eINSTANCE.getCITSFrame_Latitude();
+
+		/**
+		 * The meta object literal for the '<em><b>Longitude</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__LONGITUDE = eINSTANCE.getCITSFrame_Longitude();
+
+		/**
+		 * The meta object literal for the '<em><b>Speed Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__SPEED_VALUE = eINSTANCE.getCITSFrame_SpeedValue();
+
+		/**
+		 * The meta object literal for the '<em><b>Heading Value</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__HEADING_VALUE = eINSTANCE.getCITSFrame_HeadingValue();
+
+		/**
+		 * The meta object literal for the '<em><b>Brake Pedal Engaged</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__BRAKE_PEDAL_ENGAGED = eINSTANCE.getCITSFrame_BrakePedalEngaged();
+
+		/**
+		 * The meta object literal for the '<em><b>Gas Pedal Engaged</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__GAS_PEDAL_ENGAGED = eINSTANCE.getCITSFrame_GasPedalEngaged();
+
+		/**
+		 * The meta object literal for the '<em><b>Emergency Brake Engaged</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__EMERGENCY_BRAKE_ENGAGED = eINSTANCE.getCITSFrame_EmergencyBrakeEngaged();
+
+		/**
+		 * The meta object literal for the '<em><b>Collision Warning Engaged</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__COLLISION_WARNING_ENGAGED = eINSTANCE.getCITSFrame_CollisionWarningEngaged();
+
+		/**
+		 * The meta object literal for the '<em><b>Acc Engaged</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__ACC_ENGAGED = eINSTANCE.getCITSFrame_AccEngaged();
+
+		/**
+		 * The meta object literal for the '<em><b>Cruise Control Engaged</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__CRUISE_CONTROL_ENGAGED = eINSTANCE.getCITSFrame_CruiseControlEngaged();
+
+		/**
+		 * The meta object literal for the '<em><b>Speed Limiter Engaged</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__SPEED_LIMITER_ENGAGED = eINSTANCE.getCITSFrame_SpeedLimiterEngaged();
+
+		/**
+		 * The meta object literal for the '<em><b>Certificate ID</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute CITS_FRAME__CERTIFICATE_ID = eINSTANCE.getCITSFrame_CertificateID();
+
 	}
 
 } //pdp4engDesignPackage
diff --git a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/util/pdp4engDesignAdapterFactory.java b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/util/pdp4engDesignAdapterFactory.java
index 05d1e63..7769a91 100644
--- a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/util/pdp4engDesignAdapterFactory.java
+++ b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/util/pdp4engDesignAdapterFactory.java
@@ -23,6 +23,7 @@
 
 import org.eclipse.emf.ecore.EObject;
 
+import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CallProcess;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CompositeData;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Data;
@@ -156,6 +157,10 @@
 				return createSmartGridFrameAdapter();
 			}
 			@Override
+			public Adapter caseCITSFrame(CITSFrame object) {
+				return createCITSFrameAdapter();
+			}
+			@Override
 			public Adapter defaultCase(EObject object) {
 				return createEObjectAdapter();
 			}
@@ -386,6 +391,20 @@
 	}
 
 	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame <em>CITS Frame</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame
+	 * @generated
+	 */
+	public Adapter createCITSFrameAdapter() {
+		return null;
+	}
+
+	/**
 	 * Creates a new adapter for the default case.
 	 * <!-- begin-user-doc -->
 	 * This default implementation returns null.
diff --git a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/util/pdp4engDesignSwitch.java b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/util/pdp4engDesignSwitch.java
index 59b581b..7646c9e 100644
--- a/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/util/pdp4engDesignSwitch.java
+++ b/plugins/design/org.eclipse.papyrus.pdp4eng.designer.profile/src/org/eclipse/papyrus/pdp4eng/designer/profile/pdp4engDesign/util/pdp4engDesignSwitch.java
@@ -21,6 +21,7 @@
 
 import org.eclipse.emf.ecore.util.Switch;
 
+import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CITSFrame;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CallProcess;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.CompositeData;
 import org.eclipse.papyrus.pdp4eng.designer.profile.pdp4engDesign.Data;
@@ -189,6 +190,13 @@
 				if (result == null) result = defaultCase(theEObject);
 				return result;
 			}
+			case pdp4engDesignPackage.CITS_FRAME: {
+				CITSFrame citsFrame = (CITSFrame)theEObject;
+				T result = caseCITSFrame(citsFrame);
+				if (result == null) result = caseData(citsFrame);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
 			default: return defaultCase(theEObject);
 		}
 	}
@@ -419,6 +427,21 @@
 	}
 
 	/**
+	 * Returns the result of interpreting the object as an instance of '<em>CITS Frame</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>CITS Frame</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseCITSFrame(CITSFrame object) {
+		return null;
+	}
+
+	/**
 	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
 	 * <!-- begin-user-doc -->
 	 * This implementation returns null;
