Sorry about this cross-post… But i think this is the right place for it…
Hi all,
well, i’m looking for teoric information on this topic.
The problem is:
i have a robot interacting with some resource managers (one for each
hardware input), and a lot of user-programs. The scheme that i make was
basically something like this:
[devc-laser] [user-prg1]
\
[Manager] — [Comm. Mngr] — [User-program Mngr]
/ /
[devc-sonar] [user-prg2]
It’s a little bit more complicated than that…
So,
i’m trying to make a really good insert-module scheme. When any new
hardware
piece being added to the robot the only thing that i should do is to
insert
a module (or something like) and the same for new user programs. Something
like Neutrino does, or the linux kernel (using insmod).
Today, every time that i add new options to the robot, i have to
re-compile the manager’s (Manager and User-program manager) source code.
It’s like an Operation-System programming. Of course a very simple, high
level operation system.
Any ideas?
I’m not shure if i explain well the problem… If anyone want, please
fell free to contact-me at e-mail.
Thanx
Leandro (lcrocha@yahoo.com)
An initial thought that I had (without knowing the specifics of what new information
the various managers need to get about the new modules) would be to have each new
module include a shared lib that the managers could load, and when the devc-newthing
is loaded it could send a message/pulse/something to the managers saying it was
active, and to load the libnewthing.so to get the interface info for the new module.
The managers could just use dlopen/dlsym of standard symbol names to get dynamic info
needed to interface with the new modules. Does this sound like it may do what you need?
-Peter
Leandro Colen <lcrocha@yahoo.com> wrote:
Sorry about this cross-post… But i think this is the right place for it…
Hi all,
well, i’m looking for teoric information on this topic.
The problem is:
i have a robot interacting with some resource managers (one for each
hardware input), and a lot of user-programs. The scheme that i make was
basically something like this:
[devc-laser] [user-prg1]
\
[Manager] — [Comm. Mngr] — [User-program Mngr]
/ /
[devc-sonar] [user-prg2]
It’s a little bit more complicated than that…
So,
i’m trying to make a really good insert-module scheme. When any new
hardware
piece being added to the robot the only thing that i should do is to
insert
a module (or something like) and the same for new user programs. Something
like Neutrino does, or the linux kernel (using insmod).
Today, every time that i add new options to the robot, i have to
re-compile the manager’s (Manager and User-program manager) source code.
It’s like an Operation-System programming. Of course a very simple, high
level operation system.
Any ideas?
I’m not shure if i explain well the problem… If anyone want, please
fell free to contact-me at e-mail.
Thanx
Leandro (> lcrocha@yahoo.com> )
Yes, this is what i talked about…
But you say some new things to me… dlopen/dlsym ?? This kind of
dynamic-info and dynamic-load are very new to me… Where can i find more
info about this?
Thanx.
Leandro
“Peter Graves” <pgraves@node27.ott.qnx.com> escreveu na mensagem
news:aiojjg$qbc$1@nntp.qnx.com…
An initial thought that I had (without knowing the specifics of what new
information
the various managers need to get about the new modules) would be to have
each new
module include a shared lib that the managers could load, and when the
devc-newthing
is loaded it could send a message/pulse/something to the managers saying
it was
active, and to load the libnewthing.so to get the interface info for the
new module.
The managers could just use dlopen/dlsym of standard symbol names to get
dynamic info
needed to interface with the new modules. Does this sound like it may do
what you need?
-Peter
Leandro Colen <> lcrocha@yahoo.com> > wrote:
Sorry about this cross-post… But i think this is the right place for
it…
Hi all,
well, i’m looking for teoric information on this topic.
The problem is:
i have a robot interacting with some resource managers (one for each
hardware input), and a lot of user-programs. The scheme that i make was
basically something like this:
[devc-laser]
[user-prg1]
[Manager] — [Comm. Mngr] — [User-program Mngr]
/
/
[devc-sonar]
[user-prg2]
It’s a little bit more complicated than that…
So,
i’m trying to make a really good insert-module scheme. When any new
hardware
piece being added to the robot the only thing that i should do is to
insert
a module (or something like) and the same for new user programs.
Something
like Neutrino does, or the linux kernel (using insmod).
Today, every time that i add new options to the robot, i have to
re-compile the manager’s (Manager and User-program manager) source code.
It’s like an Operation-System programming. Of course a very simple, high
level operation system.
Any ideas?
I’m not shure if i explain well the problem… If anyone want, please
fell free to contact-me at e-mail.
Thanx
Leandro (> lcrocha@yahoo.com> )
\
Take a look in the QNX help:
http://www.qnx.com/developer/docs/momentics_nc_docs/neutrino/lib_ref/d/dlopen.html
http://www.qnx.com/developer/docs/momentics_nc_docs/neutrino/lib_ref/d/dlsym.html
these will let you load a shared library at runtime, and access any symbols that
are contained in it.
-Peter
Leandro Colen <lcrocha@yahoo.com> wrote:
Yes, this is what i talked about…
But you say some new things to me… dlopen/dlsym ?? This kind of
dynamic-info and dynamic-load are very new to me… Where can i find more
info about this?
Thanx.
Leandro
“Peter Graves” <> pgraves@node27.ott.qnx.com> > escreveu na mensagem
news:aiojjg$qbc$> 1@nntp.qnx.com> …
An initial thought that I had (without knowing the specifics of what new
information
the various managers need to get about the new modules) would be to have
each new
module include a shared lib that the managers could load, and when the
devc-newthing
is loaded it could send a message/pulse/something to the managers saying
it was
active, and to load the libnewthing.so to get the interface info for the
new module.
The managers could just use dlopen/dlsym of standard symbol names to get
dynamic info
needed to interface with the new modules. Does this sound like it may do
what you need?
-Peter
Leandro Colen <> lcrocha@yahoo.com> > wrote:
Sorry about this cross-post… But i think this is the right place for
it…
Hi all,
well, i’m looking for teoric information on this topic.
The problem is:
i have a robot interacting with some resource managers (one for each
hardware input), and a lot of user-programs. The scheme that i make was
basically something like this:
[devc-laser]
[user-prg1]
[Manager] — [Comm. Mngr] — [User-program Mngr]
/
/
[devc-sonar]
[user-prg2]
It’s a little bit more complicated than that…
So,
i’m trying to make a really good insert-module scheme. When any new
hardware
piece being added to the robot the only thing that i should do is to
insert
a module (or something like) and the same for new user programs.
Something
like Neutrino does, or the linux kernel (using insmod).
Today, every time that i add new options to the robot, i have to
re-compile the manager’s (Manager and User-program manager) source code.
It’s like an Operation-System programming. Of course a very simple, high
level operation system.
Any ideas?
I’m not shure if i explain well the problem… If anyone want, please
fell free to contact-me at e-mail.
Thanx
Leandro (> lcrocha@yahoo.com> )
\