Modelado de cuatro pistones sincronizados, comportandose como

un motor de combustion interna en SystemC

Arturo Pinto | A00819209
Tecnologico de Monterrey
Monterrey, Mexico
Email: arturo.pinto.mx@ieee.org

Gustavo Mendoza | A00819209

Tecnologico de Monterrey
Monterrey, Mexico
Email: A00819209@itesm.mx

Abstract
En este reporte se describira el modelo del comportamiento de cuatro pistones con sus respectivas
valvulas de admision y de escape. Este modelo se programo en SystemC y SystemC AMS.

1.

Introduccion

En este proyecto se hara uso de SystemC AMS para hacer un modelado del comportamiento
de un motor de combustion interna donde tendremos como entradas la posicion del los pistones
y como salidas el comportamiento de las valvulas de admision y escape as como el punto de
ignicion provocado por la buja.

2.

SystemC

SystemC es un estandar aprobado por la IEEE Standards Association como IEEE 1666-2005 [1].
SystemC es una librera de clases basada en ANSI standard C++. Esta librera esta disenada para
el diseno de sistemas complejos y que son hbridos entre software y hardware. En la librera se
implementan conceptos de hardware como relojes, puertos, concurrencia, etc.
Esta librera consiste en varias capas de programacion y un kernel el cual registra funciones para
simular una ejecucion en paralelo.

Preprint submitted to Tec de monterrey

3 de diciembre de 2015

2.1.

SystemC-AMS

SystemC AMS es un estandar de Accellera Systems, pero es parte del proyecto P1666.1 de la
IEEE como propuesta a convertirse en un estandar de la IEEE [2]. Este estandar satisface las
necesidades de la industria electronica al tener un lenguaje estandarizado de modelado a nivel
sistema para aplicaciones con el uso de senales analogicas y/o mixtas basados en SystemC.

3.

Ciclo Otto

El ciclo Otto es un ciclo de combustion interna que posee dos o cuatro pasos. En este proyecto
se modelara un ciclo Otto de 4 pasos.

Figura 1: Ciclo Otto a cuatro pasos

3.1.

Admision

En este paso el piston baja con la valvula de admision abierta, aumentando la cantidad de mezcla
(aire-combustible) en la camara.
3.2.

Compresion

En este paso el piston sube comprimiendo la mezcla. Dada la velocidad del proceso se supone
que la mezcla no tiene posibilidad de intercambiar calor con el ambiente, por lo que el proceso
es adiabatico.
3.2.1.

Combustion

Al final de la compresion cuando el piston se localiza en su punto mas alto, salta la chispa de la
buja y la explosion da paso al tercer paso.
3.3.

Expansion

La explosion de la mezcla produce una fuerza sobre el piston empujandolo hacia abajo. De nuevo,
por ser un proceso muy rapido se aproxima por una curva adiabatica.
2

3.4.

Escape

Se abre la valvula de escape y el gas sale al exterior, empujado por el piston a una temperatura
mayor que la inicial, siendo sustituido por la misma cantidad de mezcla fra en la siguiente
admision.

4.

Modelo de un piston

Un piston se comporta como un mecanismo Biela-Manivela tal como se muestra en la figura 2, y

usando la ecuacion 1 podemos obtener la posicion del cilindro con respecto al centro de la biela
en este caso el a rbol de levas dependiendo del angulo de este.

Figura 2: Diagrama Biela-Manivela

s
f () = cos +
2

r
l2

 s 2
2

sin2

(1)

s
2

:= Radio de la manivela
:= Angulo de la manivela
l := Longitud de la biela
De la ecuacion 1 [3] es posible sustituir por t quedando la ecuacion con respecto al tiempo t y
la velocidad angular . Pero a la vez es posible sustituirla por 2R
60 donde R son lar revoluciones
por minuto del motor. luego de hacer estas sustituciones nos queda la ecuacion 2 .
s
2 R
f (R) = cos(
t) +
2
60
La ecuacion 2 es la que modelaremos.

r
l2

 s 2
2

sin2 (

2 R
t)
60

(2)

5.

Resultados

Figura 3: Diagrama de ciclo Otto Piston 1

Figura 4: Ciclo Otto Motor a 4 tiempos.

Figura 5: Sequencia de Ignicion: Buja 1, Buja 3, Buja 4, Buja 5.

Figura 6: Diagrama de ciclo otto piston 2.

6.
6.1.

Codigo
TestBench.cpp

#include "pistones.h"
#include "ecu.h
int sc_main(int argn, char* argc[])
{
sca_tdf::sca_signal<double>
sca_tdf::sca_signal<bool>

sig_1, sig_2, sig_3, sig_4;

sen1,buj1, buj2, buj3, buj4,
vadm1, vadm2, vadm3, vadm4,
vesc1, vesc2, vesc3, vesc4;

pistones pist1("pist1");
pist1.out1(sig_1);
pist1.out2(sig_2);
pist1.out3(sig_3);
pist1.out4(sig_4);
5

ecu ecu1("ecu1");
ecu1.ent1(sig_1);
ecu1.ent2(sig_2);
ecu1.ent3(sig_3);
ecu1.ent4(sig_4);
ecu1.out1b(buj1);
ecu1.out2b(buj2);
ecu1.out3b(buj3);
ecu1.out4b(buj4);
ecu1.out1a(vadm1);
ecu1.out2a(vadm2);
ecu1.out3a(vadm3);
ecu1.out4a(vadm4);
ecu1.out1e(vesc1);
ecu1.out2e(vesc2);
ecu1.out3e(vesc3);
ecu1.out4e(vesc4);
sca_trace_file* tfp = sca_create_tabular_trace_file("Proyecto_Final");
sca_trace(tfp, sig_1, "Piston1");
sca_trace(tfp, sig_2, "Piston2");
sca_trace(tfp, sig_3, "Piston3");
sca_trace(tfp, sig_4, "Piston4");
sca_trace(tfp, buj1, "buj1");
sca_trace(tfp, buj2, "buj2");
sca_trace(tfp, buj3, "buj3");
sca_trace(tfp, buj4, "buj4");
sca_trace(tfp, vadm1, "vadm1");
sca_trace(tfp, vadm2, "vadm2");
sca_trace(tfp, vadm3, "vadm3");
sca_trace(tfp, vadm4, "vadm4");
sca_trace(tfp, vesc1, "vesc1");
sca_trace(tfp, vesc2, "vesc2");
sca_trace(tfp, vesc3, "vesc3");
sca_trace(tfp, vesc4, "vesc4");
sc_start(100.0, SC_MS);
sca_close_tabular_trace_file(tfp);
return 0;
}

6.2.

pistones.cpp

#define _USE_MATH_DEFINES
#include "pistones.h"
#include <cmath>
void pistones::set_attributes()
{
out1.set_timestep(1.0, SC_US);
out2.set_timestep(1.0, SC_US);
out3.set_timestep(1.0, SC_US);
out4.set_timestep(1.0, SC_US);
}
void pistones::processing()
{
double t = out1.get_time().to_seconds();
double w=(2.0 * M_PI *rpm);
double l2=pow(l,2);
double r2=pow(r,2);
double x1= (r*std::cos(w*t))+(sqrt(l2-(r2*pow((std::sin(w*t)),2))));
double x2=(r*std::cos(w*t+180))+(sqrt(l2-(r2*pow((std::sin(w*t+180)),2))));
double x3=(r*std::cos(w*t+360))+(sqrt(l2-(r2*pow((std::sin(w*t+360)),2))));
double x4=(r*std::cos(w*t+720))+(sqrt(l2-(r2*pow((std::sin(w*t+720)),2))));
out1.write(x1);
out2.write(x2);
out3.write(x3);
out4.write(x4);
}

6.3.

pistones.h

#ifndef SIN_SOURCE_H
#define SIN_SOURCE_H
#include <systemc-ams.h>
SCA_TDF_MODULE(pistones)
{
sca_tdf::sca_out<double> out1,out2,out3,out4;
//parameter
double rpm; //
revoluciones por minuto
double A;
// angulo de cigue~
nal
float l;
// longitud de biela (distancia entre piston y cigue~
nal)
float r;
// radio del cigue~
nal
void set_attributes();
void processing();
SCA_CTOR(pistones)
: out1("out1"), out2("out2"), out3("out3"), out4("out4"),
r(1.8), rpm(50),l(6) {}
// Valores iniciales de radio de cigue~
nal,
//revoluciones por minuto en Hz, y longitud de biela.
};
#endif /* SIN_SOURCE_H */

6.4.

ecu.cpp

#include "ecu.h"
bool

int

indi1b
indi2b
indi3b
indi4b
ei1b =
ei2b =
ei3b =
ei4b =

= true,
= true,
= true,
= true,
0, di1b
0, di2b
0, di3b
0, di4b

indi1a = true,
indi2a = true,
indi3a = true,
indi4a = true,
= 0, ei1a = 0,
= 0, ei2a = 0,
= 0, ei3a = 0,
= 0, ei4a = 0,

indi1e
indi2e
indi3e
indi4e
di1a =
di2a =
di3a =
di4a =

= true,
= true,
= true,
= true;
0, ei1e
0, ei2e
0, ei3e
0, ei4e

=
=
=
=

-1,
-1,
-1,
-1,

di1e
di2e
di3e
di4e

=
=
=
=

-1,
-1,
-1,
-1,

i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0,s=0,u=0,v=0,w=0,x=0,y=0,a=-1,b=-1,c=-1,d=-1;

void ecu::processing()
// Describe time-domain behaviour
{
// ===================================================
//
CAMARA 1
// ===================================================
// Begin
// ===================================================
// ===============================================
// Bujia 1
// ===============================================
if(ent1.read()>7.75)
{
if (indi1b)
{
ei1b++;
if (ei1b == 2)
{
out1b.write(true);
ei1b = 0;
}
indi1b = false;
}
}
if(ent1.read()<7.75)
{
if (!indi1b)
{
di1b++;
if (di1b == 2)
9

{
out1b.write(false);
di1b = 0;
}
indi1b = true;
}
}
// ===============================================
// Valvula de admision 1
// ===============================================
if(ent1.read()<4.4)
{
if (indi1a)
{
ei1a++;
if (ei1a == 1)
{
out1a.write(true);
}
else
{
ei1a = 0;
}
indi1a = false;
}
}
if(ent1.read()>4.4)
{
if (!indi1a)
{
di1a++;
if (di1a == 1)
{
out1a.write(false);
}
else
{
di1a = 0;
}
indi1a = true;
}
}
// ===============================================
10

// Valvula de escape 1
// ===============================================
if(ent1.read()>6.1)
{
if (indi1e)
{
ei1e++;
if (ei1e == 2)
{
out1e.write(true);
ei1e = 0;
}
indi1e = false;
}
}
if(ent1.read()<6.1)
{
if (!indi1e)
{
di1e++;
if (di1e == 1)
{
out1e.write(false);
di1e = 0;
}
indi1e = true;
}
}
// ===================================================
// End
// ===================================================

//
//
//
//
//

===================================================
CAMARA 2
===================================================
Begin
===================================================
//
//
//
if
{

===============================================
Bujia 2
===============================================
(ent2.read()>7.75)
if (indi2b)
11

{
ei2b++;
if (ei2b == 2)
{
out2b.write(true);
ei2b = 0;
}
indi2b = false;
}
}
if (ent2.read()<7.75)
{
if (!indi2b)
{
di2b++;
if (di2b == 2)
{
out2b.write(false);
di2b = 0;
}
indi2b = true;
}
}
//
//
//
if
{

===============================================
Valvula de admision 2
===============================================
(ent2.read()<4.4)
if (indi2a)
{
ei2a++;
if (ei2a == 1)
{
out2a.write(true);
}
else
{
ei2a = 0;
}
indi2a = false;
}

}
if (ent2.read()>4.4)
12

{
if (!indi2a)
{
di2a++;
if (di2a == 1)
{
out2a.write(false);
}
else
{
di2a = 0;
}
indi2a = true;
}
}
//
//
//
if
{

===============================================
Valvula de escape 2
===============================================
(ent2.read()>6.1)
if (indi2e)
{
ei2e++;
if (ei2e == 2)
{
out2e.write(true);
ei2e = 0;
}
indi2e = false;
}

}
if (ent2.read()<6.1)
{
if (!indi2e)
{
di2e++;
if (di2e == 1)
{
out2e.write(false);
di2e = 0;
}
indi2e = true;
}
}
13

// ===================================================
// End
// ===================================================

//
//
//
//
//

===================================================
CAMARA 3
===================================================
Begin
===================================================
//
//
//
if
{

===============================================
Bujia 3
===============================================
(ent3.read()>7.75)
if (indi3b)
{
ei3b++;
if (ei3b == 2)
{
out3b.write(true);
ei3b = 0;
}
indi3b = false;
}

}
if (ent3.read()<7.75)
{
if (!indi3b)
{
di3b++;
if (di3b == 2)
{
out3b.write(false);
di3b = 0;
}
indi3b = true;
}
}
//
//
//
if
{

===============================================
Valvula de admision 3
===============================================
(ent3.read()<4.4)
14

if (indi3a)
{
ei3a++;
if (ei3a == 1)
{
out3a.write(true);
}
else
{
ei3a = 0;
}
indi3a = false;
}
}
if (ent3.read()>4.4)
{
if (!indi3a)
{
di3a++;
if (di3a == 1)
{
out3a.write(false);
}
else
{
di3a = 0;
}
indi3a = true;
}
}
//
//
//
if
{

===============================================
Valvula de escape 3
===============================================
(ent3.read()>6.1)
if (indi3e)
{
ei3e++;
if (ei3e == 2)
{
out3e.write(true);
ei3e = 0;
}
indi3e = false;
15

}
}
if (ent3.read()<6.1)
{
if (!indi3e)
{
di3e++;
if (di3e == 1)
{
out3e.write(false);
di3e = 0;
}
indi3e = true;
}
}
// ===================================================
// End
// ===================================================

//
//
//
//
//

===================================================
CAMARA 4
===================================================
Begin
===================================================
//
//
//
if
{

===============================================
Bujia 4
===============================================
(ent4.read()>7.75)
if (indi4b)
{
ei4b++;
if (ei4b == 2)
{
out4b.write(true);
ei4b = 0;
}
indi4b = false;
}

}
if (ent4.read()<7.75)
{
16

if (!indi4b)
{
di4b++;
if (di4b == 2)
{
out4b.write(false);
di4b = 0;
}
indi4b = true;
}
}
//
//
//
if
{

===============================================
Valvula de admision 4
===============================================
(ent4.read()<4.4)
if (indi4a)
{
ei4a++;
if (ei4a == 1)
{
out4a.write(true);
}
else
{
ei4a = 0;
}
indi4a = false;
}

}
if (ent4.read()>4.4)
{
if (!indi4a)
{
di4a++;
if (di4a == 1)
{
out4a.write(false);
}
else
{
di4a = 0;
}
indi4a = true;
17

}
}
//
//
//
if
{

===============================================
Valvula de escape 4
===============================================
(ent4.read()>6.1)
if (indi4e)
{
ei4e++;
if (ei4e == 2)
{
out4e.write(true);
ei4e = 0;
}
indi4e = false;
}

}
if (ent4.read()<6.1)
{
if (!indi4e)
{
di4e++;
if (di4e == 1)
{
out4e.write(false);
di4e = 0;
}
indi4e = true;
}
}
// ===================================================
// End
// ===================================================
}

18

6.5.

ecu.h

#ifndef SINK_H
#define SINK_H
#include <systemc-ams.h>

SCA_TDF_MODULE(ecu)
{
sca_tdf::sca_in<double>
sca_tdf::sca_out<bool>

ent1, ent2, ent3, ent4;

out1b, out2b, out3b, out4b,
out1a, out2a, out3a, out4a,
out1e, out2e, out3e, out4e;

SCA_CTOR(ecu) :
ent1("ent1"), ent2("ent2"), ent3("ent3"), ent4("ent4"),
out1b("out1b"), out2b("out2b"), out3b("out3b"), out4b("out4b"),
out1a("out1a"), out2a("out2a"), out3a("out3a"), out4a("out4a"),
out1e("out1e"), out2e("out2e"), out3e("out3e"), out4e("out4e")
{}
void processing();

// Describe time-domain behaviour

};
#endif // SINK_H

Referencias
[1] IEEE SA - 1666-2011 - IEEE Standard for Standard SystemC Language Reference Manual. [Online]. Available:
https://standards.ieee.org/findstds/standard/1666-2011.html
[2] IEEE SA - P1666.1 - IEEE Draft SystemC Analog/Mixed-Signal (AMS) extensions Language Reference Manual.
[Online]. Available: https://standards.ieee.org/develop/project/1666.1.html
[3] K. C. Weston, Energy Conversion, 1st ed. PWS Publishers, 1992. [Online]. Available: http://www.personal.utulsa.
edu/{}kenneth-weston/

19