Le 2014-11-04 08:44, René Doß a écrit :
Hi whygee,
The trick there is that it's NOT the C side that controls the
simulation,
but the VHDL side that sets the thing up.
Yes this is what I need a control from C side.
So you have to wrap your VHDL design around a VHDL code that can yield
control
using certain tricks.
For example, the real-time clock actually stops/pauses the simulator
when it has finished all its deltas.
Doing otherwise is much more difficult.
So your overall events system must work in a "polled" way,
with your C function called everytime GHDL has done its work for the
current cycle.
Polled way is not nice, but if it the only way.
This is also my opinion.
Ok I can make a process for polling.
What ist the wait until time/event?
process
wait until C function
?
Using "wait" does not work, because the function can return an integer,
or an access, or a classic type,
but not an event. Events (that can wake up a process) are internal
structures.
But events are triggered when a process changes a signal. That's how you
can do it.
It doesn't work when your C code changes the signal because the C
misses all the internal bookkeeping
and other checks and stuffs...
So you write a process, where you poll (in a "while") the condition from
the C side, by calling a function.
When the C function returns something in particular, then you assign the
signal that acts like a "semaphore"
and wait for something else, so the signal can be propagated and other
processes can be woken up.
There are two cases : either your sim is a "free running" loop, or it is
always waiting for new events from C.
The free running loop is quite simple, you insert the polling in the
main loop, which might be controlled
by a clock signal in VHDL. So you have :
process (my_clock) is
begin
if my_C_function() = 42 then
my_semaphore = not my_semaphore;
end if;
end process;
Don't forget to initialise my_semaphore : std_ulogic := '0' or else the
NOT will return
the same meta-value all the time...
This process is woken up at every edge of clock (rising, falling) so the
my_semaphore signal is
synchronous to the simulation. Then all the processes that are sensitive
to my_semaphore
will wake up and do your bidding.
The waiting loop can be more complex. If nothing is available from the C
side, the C code
can either delay() and/or execute more work.
You can start from http://ygdes.com/GHDL/clk/ which synchronises a
simple simulation
to the host's computer clock, with a blocking delay(). I just uploaded
these explanations
in the directory for future references :-)
Hope this helps,
YG
_______________________________________________
Ghdl-discuss mailing list
[email protected]
https://mail.gna.org/listinfo/ghdl-discuss
