473,839 Members | 1,540 Online
Bytes | Software Development & Data Engineering Community
+ Post

Home Posts Topics Members FAQ

clock() function

I'm using clock() to time parts of my code
e.g.
clk1 = clock();
/* code */
clk2 = clock();
/* calculate time in secs */
......
clk1 = clock();
/* code */
clk2 = clock();
/* calculate time in secs */

I have to do this a couple of more times. I'm worried after reading the
man page for clock() which says:
USAGE
The value returned by clock() is defined in microseconds for
compatibility with systems that have CPU clocks with much
higher resolution. Because of this, the value returned will
wrap around after accumulating only 2147 seconds of CPU time
(about 36 minutes).

Does this mean if my code runs more than 36 mins. the timings calculated
will be wrong?

Nov 13 '05
33 47649
Da*****@cern.ch (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
The words: "the implementation' s best approximation" effectively mean that
an implementation can return *anything* from a clock() call, including a
negative value, without having its conformance affected.

I would hope that an implementation as described by the OP (i.e. most
Unix implementations ) constantly returns -1 after 36 minutes of CPU time,
No! Why would you hope that?


Because this is what the standard actually says:

If the processor time used is not available or its value cannot
^^^^^^^^^^^^^^^ ^^^^
be represented, the function returns the value (clock_t)(-1)
^^^^^^^^^^^^^^


Yeah, from our favorite legalistic point of view that would be the
thing to hope for. I forgot;p

Daniel Vallstrom

Dan

Nov 13 '05 #21
"Keith Thompson" <ks*@cts.com> wrote in message news:lz******** ****@cts.com...
"Mike Wahler" <mk******@mkwah ler.net> writes:
"Dan Pop" <Da*****@cern.c h> wrote in message
news:bm******** **@sunnews.cern .ch... [...]
Because this is what the standard actually says:

If the processor time used is not available or its value cannot
^^^^^^^^^^^^^^^ ^^^^
be represented, the function returns the value (clock_t)(-1)
^^^^^^^^^^^^^^


Should I understand this to mean that the 'wrapping'
to zero described by the documentation posted by OP
is not an allowed 'implementation-defined' component
of 'clock()' behavior? "Zero" might not be of any
practical use, but perhaps it *could* be called
"best approximation" rather than "not representable".

Are saying that a 'clock()' which "wraps" to zero is
definitely not standard conforming?


On one system I tested yesterday (Solaris 8), clock_t is a 32-bit
signed integer type. The values returned by the clock() function wrap
around to negative values. That's far more useful than returning -1
after 2147 seconds, but it looks like it violates the standard.


As long as it doesn't wrap to (clock_t)(-1), then it is fine. You'll
likely want to cast it to unsigned of the same size. If you detect
a clock() result of (clock_t)(-1), then all bets are off.

For a 32-bit clock_t type, you are stuck with 32-bit resolution
unless there is also a non-standard library call than can return
the number of wrap-arounds since the last call to clock(). (Thus,
effectively increasing the size to 64-bits.)
Probably be best solution in this case would be to make clock_t a
64-bit type (as it already is on some platforms).


That is probably a better solution that would conform
to the standard.
Nov 13 '05 #22
"Mike Wahler" <mk******@mkwah ler.net> wrote in message news:<64******* **********@news read3.news.pas. earthlink.net>. ..
"Dan Pop" <Da*****@cern.c h> wrote in message
news:bm******** **@sunnews.cern .ch...
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...> The words: "the implementation' s best approximation" effectively mean that> an implementation can return *anything* from a clock() call, including a> negative value, without having its conformance affected.
>
> I would hope that an implementation as described by the OP (i.e. most
> Unix implementations ) constantly returns -1 after 36 minutes of CPU time,
No! Why would you hope that?


Because this is what the standard actually says:

If the processor time used is not available or its value cannot
^^^^^^^^^^^^^^^ ^^^^
be represented, the function returns the value (clock_t)(-1)
^^^^^^^^^^^^^^


Should I understand this to mean that the 'wrapping'
to zero described by the documentation posted by OP
is not an allowed 'implementation-defined' component
of 'clock()' behavior?


No. Read the whole clock() description. Dan even explicitly say
in the text you quote above that almost anything goes since it
can be argued that it's "the implementation' s best approximation".
He just *hopes* that implementations return -1 since a literal
reading perhaps suggests that. An other approach, and IMO better,
would be to note that wraparounds could be legal, that they are
more useful and common practice, and therefor use wraparounds.

Compare e.g. with the issue if implementations are allowed to
return memory back to the OS (which IMO they certainly are).
You have to make up your own mind.
"Zero" might not be of any
practical use, but perhaps it *could* be called
"best approximation" rather than "not representable".

Are saying that a 'clock()' which "wraps" to zero is
definitely not standard conforming?
The clock type is often signed and then it would wrap to e.g. -2^31.
Anyway, I bet that most or all of the compilers you consider
conforming do wraparounds.
Daniel Vallstrom


-Mike

Nov 13 '05 #23
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
>Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
>> The words: "the implementation' s best approximation" effectively mean that
>> an implementation can return *anything* from a clock() call, including a
>> negative value, without having its conformance affected.
>>
>> I would hope that an implementation as described by the OP (i.e. most
>> Unix implementations ) constantly returns -1 after 36 minutes of CPU time,
>
>No! Why would you hope that?


Because this is what the standard actually says:

If the processor time used is not available or its value cannot
^^^^^^^^^^^^^^^ ^^^^
be represented, the function returns the value (clock_t)(-1)
^^^^^^^^^^^^^^


Yeah, from our favorite legalistic point of view that would be the
thing to hope for. I forgot;p


It's also from a practical point of view. Imagine that the second clock_t
value you obtain is greater than the first one: how can you tell whether
wraparound occured and how many times between the two clock_t calls?

What is better: no answer or a hopelessly wrong answer?

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Nov 13 '05 #24
Da*****@cern.ch (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:

>Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
>> The words: "the implementation' s best approximation" effectively mean that
>> an implementation can return *anything* from a clock() call, including a
>> negative value, without having its conformance affected.
>>
>> I would hope that an implementation as described by the OP (i.e. most
>> Unix implementations ) constantly returns -1 after 36 minutes of CPU time,
>
>No! Why would you hope that?

Because this is what the standard actually says:

If the processor time used is not available or its value cannot
^^^^^^^^^^^^^^^ ^^^^
be represented, the function returns the value (clock_t)(-1)
^^^^^^^^^^^^^^
Yeah, from our favorite legalistic point of view that would be the
thing to hope for. I forgot;p


It's also from a practical point of view. Imagine that the second clock_t
value you obtain is greater than the first one: how can you tell whether
wraparound occured and how many times between the two clock_t calls?


By requiring that clock calls are made frequent enough. In the OP's
case he would have to call the clock time-out library function at
least every 36 or 72 minutes.
What is better: no answer or a hopelessly wrong answer?
No answer is much better than a possibly wrong answer if the risk of
answering wrong is high enough. But that's not the case here. In all
programs I have used wraparounds in, there is no real risk of missing
a (relevant) wraparound.

Though, perhaps the implementors of clock did wraparounds because it
was the easiest solution rather than something thought through. And
then the standard writers felt that they had to allow the practice?
Daniel Vallstrom

Dan

Nov 13 '05 #25
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
>Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
>> In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
>>
>> >Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
>> >> The words: "the implementation' s best approximation" effectively mean that
>> >> an implementation can return *anything* from a clock() call, including a
>> >> negative value, without having its conformance affected.
>> >>
>> >> I would hope that an implementation as described by the OP (i.e. most
>> >> Unix implementations ) constantly returns -1 after 36 minutes of CPU time,
>> >
>> >No! Why would you hope that?
>>
>> Because this is what the standard actually says:
>>
>> If the processor time used is not available or its value cannot
>> ^^^^^^^^^^^^^^^ ^^^^
>> be represented, the function returns the value (clock_t)(-1)
>> ^^^^^^^^^^^^^^
>
>Yeah, from our favorite legalistic point of view that would be the
>thing to hope for. I forgot;p
It's also from a practical point of view. Imagine that the second clock_t
value you obtain is greater than the first one: how can you tell whether
wraparound occured and how many times between the two clock_t calls?


By requiring that clock calls are made frequent enough. In the OP's
case he would have to call the clock time-out library function at
least every 36 or 72 minutes.


How frequent is "frequent enough" in a *portable* program? Is the
standard preventing an implementation from wrapping around after 1 second?
After 1 millisecond?
What is better: no answer or a hopelessly wrong answer?


No answer is much better than a possibly wrong answer if the risk of
answering wrong is high enough. But that's not the case here. In all
programs I have used wraparounds in, there is no real risk of missing
a (relevant) wraparound.


Is this a property of the programs (see my remark above) or of the
actual implementations you have used?
Though, perhaps the implementors of clock did wraparounds because it
was the easiest solution rather than something thought through. And
then the standard writers felt that they had to allow the practice?


The C standard certainly tried to accomodate existing practice, but it
also did its best to discourage wraparounds.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Nov 13 '05 #26
Da*****@cern.ch (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:

>Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
>> In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
>>
>> >Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
>> >> The words: "the implementation' s best approximation" effectively mean that
>> >> an implementation can return *anything* from a clock() call, including a
>> >> negative value, without having its conformance affected.
>> >>
>> >> I would hope that an implementation as described by the OP (i.e. most
>> >> Unix implementations ) constantly returns -1 after 36 minutes of CPU time,
>> >
>> >No! Why would you hope that?
>>
>> Because this is what the standard actually says:
>>
>> If the processor time used is not available or its value cannot
>> ^^^^^^^^^^^^^^^ ^^^^
>> be represented, the function returns the value (clock_t)(-1)
>> ^^^^^^^^^^^^^^
>
>Yeah, from our favorite legalistic point of view that would be the
>thing to hope for. I forgot;p

It's also from a practical point of view. Imagine that the second clock_t
value you obtain is greater than the first one: how can you tell whether
wraparound occured and how many times between the two clock_t calls?
By requiring that clock calls are made frequent enough. In the OP's
case he would have to call the clock time-out library function at
least every 36 or 72 minutes.


How frequent is "frequent enough" in a *portable* program? Is the
standard preventing an implementation from wrapping around after 1 second?
After 1 millisecond?


I have only claimed that it's "fairly portable" (which might
be a contradiction in terms). What do you propose if someone
needs large clock timings? I could try some non-C solution
which I don't know how to do and which probably would be
system specific and limited? Or I could fairly easily code
some C module to keep track of the wraparounds and which
will work on all systems I'm coding for.
What is better: no answer or a hopelessly wrong answer?
No answer is much better than a possibly wrong answer if the risk of
answering wrong is high enough. But that's not the case here. In all
programs I have used wraparounds in, there is no real risk of missing
a (relevant) wraparound.


Is this a property of the programs (see my remark above) or of the
actual implementations you have used?


Both. From the C compiler/system you need that it really
uses wraparounds and that the wraparounds don't occur too
frequently. Then you have to check the clock frequently
enough in the code that needs the timers. It's also
dependent on the input to the program.

This obviously isn't a perfect solution but for me at
least it seemed better than the alternative --- but
that might be because I'm too ignorant of what the
alternative would be.
Daniel Vallstrom
Though, perhaps the implementors of clock did wraparounds because it
was the easiest solution rather than something thought through. And
then the standard writers felt that they had to allow the practice?


The C standard certainly tried to accomodate existing practice, but it
also did its best to discourage wraparounds.

Dan

Nov 13 '05 #27
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...

How frequent is "frequent enough" in a *portable* program? Is the
standard preventing an implementation from wrapping around after 1 second?
After 1 millisecond?
I have only claimed that it's "fairly portable" (which might
be a contradiction in terms). What do you propose if someone
needs large clock timings?


The best solution is to remove the need for large clock timings. It has
always worked for me.
I could try some non-C solution
which I don't know how to do and which probably would be
system specific and limited?
Your own solution is implementation-specific and limited, even if it only
uses standard library functions.

Yes, when the standard library provides no satisfactory solution, there
is nothing wrong with using an implementation-specific solution.
Or I could fairly easily code
some C module to keep track of the wraparounds and which
will work on all systems I'm coding for.
This being comp.lang.c, a solution is considered portable when it relies
only on that the C specification guarantees. Or the C specification
not only doesn't guarantee wraparounds, it even does its best to outlaw
them.

Furthermore, if you detect wraparound, how do you handle it in a
*portable* way, without knowing the range and signedness of clock_t?
Is this a property of the programs (see my remark above) or of the
actual implementations you have used?


Both. From the C compiler/system you need that it really
uses wraparounds and that the wraparounds don't occur too
frequently.


You need more than that. You also need the range of clock_t, which
neither the standard nor the implementation specifies (in a portable way).
Then you have to check the clock frequently
enough in the code that needs the timers.
Frequent checks alter the measurement, because they consume CPU time,
too.
This obviously isn't a perfect solution but for me at
least it seemed better than the alternative --- but
that might be because I'm too ignorant of what the
alternative would be.


The best alternative is to reduce the time interval being measured to
a reasonable value (usually something between 1 second and 10 minutes).
If this is really not possible, implementations usually provide timing
tools without the shortcomings of clock().

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Nov 13 '05 #28
Da*****@cern.ch (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
In <17************ **************@ posting.google. com> Da************* *@safelogic.se (Daniel Vallstrom) writes:
Da*****@cern.c h (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...

How frequent is "frequent enough" in a *portable* program? Is the
standard preventing an implementation from wrapping around after 1 second?
After 1 millisecond?
I have only claimed that it's "fairly portable" (which might
be a contradiction in terms). What do you propose if someone
needs large clock timings?


The best solution is to remove the need for large clock timings. It has
always worked for me.


Sometimes that might not be possible though. E.g. I use large clock
timings in a SAT solver. The solver might get hard problems to solve and a
large time limit. More importantly one might want to try different solver
strategies a certain amount of time dependent on the total time limit.

I could try some non-C solution
which I don't know how to do and which probably would be
system specific and limited?


Your own solution is implementation-specific and limited, even if it only
uses standard library functions.


Agreed all along.

Yes, when the standard library provides no satisfactory solution, there
is nothing wrong with using an implementation-specific solution.
But the question is what is best, the C or non-C solution. As you
have pointed out the C solution makes many shady assumptions about
various things not guaranteed by the standard. But it might still be
preferable over a non-C solution if you for every actual effort to
support long clock timings for some system in a non-C way note that
the C solution would have worked just fine again.

I'm not necessarily advocating the C solution, since it's unsafe. But
if you can live with the unsafeness, the C solution might be much
easier than a non-C one, especially once you have some code for
handling long clock times.

Or I could fairly easily code
some C module to keep track of the wraparounds and which
will work on all systems I'm coding for.


This being comp.lang.c, a solution is considered portable when it relies
only on that the C specification guarantees. Or the C specification
not only doesn't guarantee wraparounds, it even does its best to outlaw
them.

Furthermore, if you detect wraparound, how do you handle it in a
*portable* way, without knowing the range and signedness of clock_t?


I'm not of course. IIRC I just tested for some typical cases and handled
them. Actually probably only the common 32 bits type, for both signed and
unsigned. For other clock_t types, the clock timing would only be accurate
until a wrap around occurs.

You see, it's getting worse for every question you ask;)

Is this a property of the programs (see my remark above) or of the
actual implementations you have used?


Both. From the C compiler/system you need that it really
uses wraparounds and that the wraparounds don't occur too
frequently.


You need more than that. You also need the range of clock_t, which
neither the standard nor the implementation specifies (in a portable way).


Yup.

Then you have to check the clock frequently
enough in the code that needs the timers.


Frequent checks alter the measurement, because they consume CPU time,
too.


'Frequently enough' doesn't mean frequent. Typically just at least once
every 32 minutes. One would of course profile the program and make
sure that the clock checks take an insignificant amount of time.
Daniel Vallstrom

This obviously isn't a perfect solution but for me at
least it seemed better than the alternative --- but
that might be because I'm too ignorant of what the
alternative would be.


The best alternative is to reduce the time interval being measured to
a reasonable value (usually something between 1 second and 10 minutes).
If this is really not possible, implementations usually provide timing
tools without the shortcomings of clock().

Dan

Nov 13 '05 #29
Da*****@cern.ch (Dan Pop) wrote in message news:<bm******* ***@sunnews.cer n.ch>...
In <ff************ *************@p osting.google.c om> ru**@webmail.co .za (goose) writes:
yes. if you want more than that at the resolution that clock()
offers, just write your own timekeeping function, using a combination
of clock() and time(). I've done this before, though i haven't the faintest
clue what I've done with the source, if you have a bash at it, you'll find
that its simple enough
I'm afraid that this is not possible at all (in a portable manner) because
there is no connection whatsoever between the times returned by these two
functions.


no, there isn't. but it is possible, at the start of the program,
to *establish* a point of reference for the 2 tmies returned by
these functions. once you have a base reference, and you know
how many times clock() wraps around in a certain time interval,
(say, once every 36 mins), then you can always use time(), check
if the return minus the last return of time() is greater than
the wraparound time, and then use clock() to get the finer granularity.

its not clean, its not neat, but it is possible, no ?

Feel free to prove me wrong, by posting your code ;-)


if i still had it, i would :-)

of course, as it was written a long time ago, it might have
used a platform function anyway, or made assumptions about
the platform. if i had the time, i'd try to write it again.

goose,
Nov 13 '05 #30

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

1
3602
by: Agency | last post by:
I'm still working on the bpm counter. I need to have at least 2 displays that are not static. One would be a clock/running time and the other would should the current beat count. How would I do this in Tkinter? I was thinkning of canvas-text, but there must be a widget for doing this kind of display. I'm a bit lost and would appreciate some help.
9
2267
by: Gino Elloso - Philippines | last post by:
Hello, I made a webpage ( @ Geocities Free Webpages ) that contains a mousetrail clock script. I simply copied the script ( including all html tags ) exactly as it was from a source webpage ( that contains only the functioning mousetrail clock ) and pasted it onto mine. But when I try to load the page I made, the clock won't show. Could someone help explain why the clock won't show on my page? Is there a special script for mousetrail...
1
1619
by: s.shahzaib.ali | last post by:
I want to make analog clock skin of windows media player so how can i roteate the layer upto 360 degrees with the help of javascript please tell me iam very anxious about it. iam the first and only skinner in Pakistan. i really need your help. Remember Analog clock Using XML LAYER Wit script of java. you just have tell me about java script i can work with xml well! HAVE A NICE DAY GOOD BYE!
6
61840
by: Charles M. Reinke | last post by:
I'm using the function clock() to measure the run time of a program so that I can compare among several different algorithms. My code looks like: #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <time.h> int main() { clock_t start, stop;
18
3376
by: roberts.noah | last post by:
Ok, so I am trying to establish how boost.timer works and I try a few things and afaict it doesn't. So I open the header to see why and run some tests to establish what is going on and it all boils down to the clock() function. Here is the code: #include <iostream> #include <cstdlib> int main(void)
30
17327
by: Matt | last post by:
Does clock_t clock() measure real time or process time? Unless I have missed something, Stroustrup's treatment in TC++PL (section D.4.4.1) is none too clear on that question. Is clock() well-implemented for the major compilers g++, VC++, and Macintosh compilers and other C++ compilers on Linux/Unix, Windows, and MacOS?
2
2835
by: cpptutor2000 | last post by:
Could some C guru suggest some possible solution to my problem? I am trying to simulate a clock and I have tried using 'gettimeofday' and some related C library functions, but I am not getting what I want - the clock should be ticking away on its own, and from time to time, an observer will read the clock value, and decide to do something else. Any hints, suggestions would be greatly appreciated. Thanks in advance for your help.
12
4102
by: cenktarhancenk | last post by:
is there a way to display a ticking clock in a web page using javascript? but not in a textbox, rather as text that i can change the style, font etc. cenk tarhan
9
8309
by: Ron Adam | last post by:
I'm having some cross platform issues with timing loops. It seems time.time is better for some computers/platforms and time.clock others, but it's not always clear which, so I came up with the following to try to determine which. import time # Determine if time.time is better than time.clock # The one with better resolution should be lower.
0
9855
marktang
by: marktang | last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However, people are often confused as to whether an ONU can Work As a Router. In this blog post, we’ll explore What is ONU, What Is Router, ONU & Router’s main usage, and What is the difference between ONU and Router. Let’s take a closer look ! Part I. Meaning of...
0
9697
by: Hystou | last post by:
Most computers default to English, but sometimes we require a different language, especially when relocating. Forgot to request a specific language before your computer shipped? No problem! You can effortlessly switch the default language on Windows 10 without reinstalling. I'll walk you through it. First, let's disable language synchronization. With a Microsoft account, language settings sync across devices. To prevent any complications,...
0
10585
jinu1996
by: jinu1996 | last post by:
In today's digital age, having a compelling online presence is paramount for businesses aiming to thrive in a competitive landscape. At the heart of this digital strategy lies an intricately woven tapestry of website design and digital marketing. It's not merely about having a website; it's about crafting an immersive digital experience that captivates audiences and drives business growth. The Art of Business Website Design Your website is...
0
10292
tracyyun
by: tracyyun | last post by:
Dear forum friends, With the development of smart home technology, a variety of wireless communication protocols have appeared on the market, such as Zigbee, Z-Wave, Wi-Fi, Bluetooth, etc. Each protocol has its own unique characteristics and advantages, but as a user who is planning to build a smart home system, I am a bit confused by the choice of these technologies. I'm particularly interested in Zigbee because I've heard it does some...
1
7828
isladogs
by: isladogs | last post by:
The next Access Europe User Group meeting will be on Wednesday 1 May 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM). In this session, we are pleased to welcome a new presenter, Adolph Dupré who will be discussing some powerful techniques for using class modules. He will explain when you may want to use classes instead of User Defined Types (UDT). For example, to manage the data in unbound forms. Adolph will...
0
7017
by: conductexam | last post by:
I have .net C# application in which I am extracting data from word file and save it in database particularly. To store word all data as it is I am converting the whole word file firstly in HTML and then checking html paragraph one by one. At the time of converting from word file to html my equations which are in the word document file was convert into image. Globals.ThisAddIn.Application.ActiveDocument.Select();...
1
4482
by: 6302768590 | last post by:
Hai team i want code for transfer the data from one system to another through IP address by using C# our system has to for every 5mins then we have to update the data what the data is updated we have to send another system
2
4064
muto222
by: muto222 | last post by:
How can i add a mobile payment intergratation into php mysql website.
3
3132
bsmnconsultancy
by: bsmnconsultancy | last post by:
In today's digital era, a well-designed website is crucial for businesses looking to succeed. Whether you're a small business owner or a large corporation in Toronto, having a strong online presence can significantly impact your brand's success. BSMN Consultancy, a leader in Website Development in Toronto offers valuable insights into creating effective websites that not only look great but also perform exceptionally well. In this comprehensive...

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.