Menu
▾
▴
Re: [Hamlib-developer] NET interop
|
From: James P. <ja...@m1...> - 2012-07-20 10:50:49
|
I very briefly looked into the callbacks and couldn't get them
working. I also think they only relate to radios with a cat interface
which reports changes EG: Kenwood.
At the time I was using a Yaesu rig and decided not to spend any real
time on it when I would have to poll for the other rigs anyway. I may
have misunderstood something but decided against persuiing it further.
If you do get it working, please let me know so I can look at
building that functionality into my wrapper when I get back into
it..... (I'm hacking hardware at the moment)
James
On 20 July 2012 00:48, Sagaert Johan <sag...@sk...> wrote:
>
> Hi James
>
> I can use hamlib now, but cant get the callbacks to wordk, they reurn 0 (OK) but are not fired when I change mode or freq.
>
> //my c wrapper
>
> HAMLIBNET_API int HamlibSetFreqCallBack(RIG *my_rig, freq_cb_t cb,void * dta)
> {
> return rig_set_freq_callback(my_rig,cb,dta);
> }
>
>
> //my pinvoveke decl
> [DllImport("HamlibNet.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> public static extern int HamlibSetModeCallBack(IntPtr my_rig, mode_cb_t cb, IntPtr dta);
>
>
>
> //my c# useage
> int i = Hamlib.HamlibSetModeCallBack(p, mymode_cb_t,(IntPtr)1234567898); // returns 0(OK)
>
>
> private int mymode_cb_t(IntPtr r, Hamlib.vfo_t vfo, Hamlib.RigMode rm, long pbw, IntPtr b)
> {
> Console.WriteLine();
> return 0;
> }
>
> It does not get fired when I manually control my rig.
>
>
>
>
> -----Oorspronkelijk bericht-----
> Van: jam...@gm... [mailto:jam...@gm...] Namens James Patterson
> Verzonden: donderdag 19 juli 2012 13:24
> Aan: Sagaert Johan
> CC: ham...@li...
> Onderwerp: Re: [Hamlib-developer] NET interop
>
> I've used Hamlib with VB.NET and C#. Here are the signatures I use
> for C#. I've written an entire .net wrapper for this stuff which I
> will eventually release but this extract should help you along the way.
>
> James
> M1DST
>
>
> public static class HamLibStatic
> {
> #region DLL References
>
> /// <summary>
> /// Allocates a new RIG handle and initializes the associated
> data for model.
> /// </summary>
> /// <param name=" model">The rig model.</param>
> /// <returns>A pointer to the RIG handle otherwise NULL if
> memory allocation failed or model is unknown (e.g. backend autoload
> failed).</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_init(int model);
>
> /// <summary>
> /// Opens communication to a radio which RIG handle has been passed by argument.
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <returns> OK if the operation has been sucessful,
> otherwise a negative value if an error occured (in which case, cause is set appropriately).</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_open(int RIGptr);
>
> /// <summary>
> /// Closes communication to a radio which RIG handle has been
> passed by argument that was previously open with open().
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <returns> OK if the operation has been sucessful,
> otherwise a negative value if an error occured.</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_close(int RIGptr);
>
> /// <summary>
> /// Release a rig handle and free associated memory
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <returns> OK if the operation has been sucessful,
> otherwise a negative value if an error occured.</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_cleanup(int RIGptr);
>
> /// <summary>
> /// Set the frequency of the target VFO
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <param name="vfo">The target VFO</param>
> /// <param name="freq">The frequency to set to</param>
> /// <returns> OK if the operation has been sucessful,
> otherwise a negative value if an error occured.</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_set_freq(int RIGptr, int vfo, double freq);
>
> /// <summary>
> /// Retrieves the frequency of the target VFO. The value
> stored at freq location equals FREQ_NONE when the current frequency
> of the VFO is not defined (e.g. blank memory).
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <param name="vfo">The target VFO</param>
> /// <param name="freq">The location where to store the current frequency</param>
> /// <returns> OK if the operation has been sucessful,
> otherwise a negative value if an error occured.</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_get_freq(int RIGptr, int vfo, ref double freq);
>
> /// <summary>
> /// Sets the mode and associated passband of the target VFO.
> The passband width must be supported by the backend of the rig.
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <param name="vfo">The target VFO</param>
> /// <param name="mode">The mode to set to</param>
> /// <param name="width">The passband width to set to</param>
> /// <returns> OK if the operation has been sucessful,
> otherwise a negative value if an error occured.</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_set_mode(int RIGptr, int vfo, RigMode mode, long width);
>
> /// <summary>
> /// Retrieves the mode and passband of the target VFO. If the backend is unable to determine the width, the width will be
> set to PASSBAND_NORMAL as a default. The value stored at mode location equals
> MODE_NONE when the current mode of the VFO is not defined (e.g.
> blank memory).
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <param name="vfo">The target VFO</param>
> /// <param name="mode">The location to store the current mode</param>
> /// <param name="width">The location to store the current passband width</param>
> /// <returns> OK if the operation has been sucessful,
> otherwise a negative value if an error occured.</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_get_mode(int RIGptr, int vfo, ref RigMode mode, ref long width);
>
> /// <summary>
> /// Sets the current VFO. The VFO can be VFO_A, VFO_B,
> VFO_C for VFOA, VFOB, VFOC respectively or VFO_MEM for Memory
> mode. Supported VFOs depends on rig capabilities.
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <param name="vfo">The VFO to set to</param>
> /// <returns> OK if the operation has been sucessful,
> otherwise a negative value if an error occured.</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_set_vfo(int RIGptr, int vfo);
>
> /// <summary>
> /// Retrieves the current VFO. The VFO can be VFO_A,
> VFO_B, VFO_C for VFOA, VFOB, VFOC respectively or VFO_MEM for
> Memory mode. Supported VFOs depends on rig capabilities.
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <param name="vfo">The location where to store the current VFO</param>
> /// <returns> OK if the operation has been sucessful,
> otherwise a negative value if an error occured.</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_get_vfo(int RIGptr, ref int vfo);
>
> /// <summary>
> /// Simple lookup returning token id assicated with name.
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <param name="name">The name of the configuration parameter</param>
> /// <returns>the token id if found, otherwise CONF_END</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_token_lookup(int RIGptr, string name);
>
> /// <summary>
> /// Set a radio configuration parameter
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <param name="token">The parameter</param>
> /// <param name="value">The value to set the parameter to</param>
> /// <returns> OK if the operation has been sucessful,
> otherwise a negative value if an error occured (in which case, cause is set appropriately).</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_set_conf(int RIGptr, int token, string value);
>
> /// <summary>
> /// Retrieves the value of a configuration paramter associated with token. The location pointed to by val must be large
> enough to hold the value of the config.
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <param name="token">The parameter</param>
> /// <param name="value">The value of the setting</param>
> /// <returns> OK if the operation has been sucessful,
> otherwise a negative value if an error occured (in which case, cause is set appropriately).</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern int rig_get_conf(int RIGptr, int token, string value);
>
> /// <summary>
> /// Retrieves some general information from the radio. This can include firmware revision, exact model name, or just
> nothing.
> /// </summary>
> /// <param name="RIGptr">The rig handle</param>
> /// <returns>A string if the operation has been sucessful, otherwise NULL if an error occured or get_info not part of
> capabilities.</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern string rig_get_info(int RIGptr);
>
> /// <summary>
> /// Returns a string describing the error code passed in the argument errnum.
> /// </summary>
> /// <param name="errnum">The error code</param>
> /// <returns>The appropriate description string, ortherwise a NULL pointer if the error code is unknown.</returns>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern string rig_rigerror(int errnum);
>
> [DllImport("libhamlib-2.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
> internal static extern string rig_strrmode(RigMode mode);
>
> #endregion
>
> }
>
>
>
>
>
>
>
>
>
>
>
> On 19 July 2012 09:31, Sagaert Johan <sag...@sk...> wrote:
>> Hi
>>
>> Is there an p/invoke interface for using the DLL in a c# project ?
>>
>>
>> 73 johan on5di
>>
>>
>>
>>
>>
>>
>>
>> ----------------------------------------------------------------------
>> --------
>> Live Security Virtual Conference
>> Exclusive live event will cover all the ways today's security and
>> threat landscape has changed and how IT managers can respond.
>> Discussions will include endpoint security, mobile security and the
>> latest in malware threats.
>> http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
>> _______________________________________________
>> Hamlib-developer mailing list
>> Ham...@li...
>> https://lists.sourceforge.net/lists/listinfo/hamlib-developer
>>
>
|