Show Posts
Pages: [1] 2 3 ... 50
1  Using Arduino / Programming Questions / Re: Error: invalid use of void expression on: July 11, 2011, 06:34:57 pm
...why it needs to then call upon the blinks function again

When you execute <sTimer2::set(5000, blinksXY), it sets up Timer 2 to generate an overflow interrupt every 5000 milliseconds. The function whose name (pointer) you give it will be executed every time Timer 2 overflows.  The way that the Timer2::set() function is defined, the function that you give it can not have any arguments.  Therefore the blinksXY() function calls the real worker function, (your original blinks()), with arguments that you have previously set up.  After that function completes its task, it returns to blinksXY(), which eventually returns from the interrupt.

Now, getting the stuff to compile is one thing;  getting it to "work" is another.

Since the blinksXY() function is part of an interrupt service routine, all interrupts are automatically disabled by the time it is entered (when Timer2 overflows).  That means that anything that uses millis() or delay() won't work, since they depend on Timer 0 interrupts.

Now, if all that your program is going to do is blink the lights and it doesn't matter whether everything else is frozen out until blinksXY() (and blinks()) have completed their tasks, then you can make a simple change by enabling the interrupts when you first enter blnksXY().  It may be satisfactory for demonstration purposes, but "real" applications may require some re-organization.  Most programmers will recommend that interrupt service routines should not do anything that requires any significant delays (including print statements).  Generally speaking, there is a good reason for this.

However...

A simple-minded demo:
Code:
#include <MsTimer2.h>

const int ledPin =  13;

// Global variables that will be parameters for
// blinksXY() so that it can call blinks() from
// a Timer 2 interrupt service routine
int blinksX;
int blinksY;

// blinksXY is called from the Timer2 overflow Interrupt
// Serivce Routine
void blinksXY(void)
{
    // Enable interrupts so that Timer 0 can generate timing
    // for delay() and millis()
    sei();
    Serial.print("blinksXY: ");Serial.println(millis());
    blinks(blinksX, blinksY);
}

void blinks(unsigned long time, int amount)
{
    Serial.print("blinks(");Serial.print(time);
    Serial.print(",");Serial.print(amount);
    Serial.println(")");
    for(int i = 0; i < amount; i++) {
        digitalWrite(ledPin, HIGH);
        Serial.print("1:");Serial.println(millis());
        delay(time);
        Serial.print("2:");Serial.println(millis());
        digitalWrite(ledPin, LOW);
        delay(time);
        Serial.print("3:");Serial.println(millis());
        Serial.println();
    }

}


void setup()
{
    Serial.begin(115200);
    pinMode(ledPin, OUTPUT);      
    blinksX = 200;
    blinksY = 3;
    MsTimer2::set(5000, blinksXY); //
    Serial.print("Starting MsTimer2 at ");
    Serial.println(millis());
    Serial.println();
    MsTimer2::start();
}

void loop() {
   // loop does nothing.  All of the action
   // is in the Timer 2 interrupt service
   // routine.
}


Output

Starting MsTimer2 at 1

blinksXY: 5001
blinks(200,3)
1:5003
2:5203
3:5404

1:5405
2:5606
3:5807

1:5808
2:6008
3:6209

blinksXY: 10001
blinks(200,3)
1:10003
2:10204
3:10405

1:10406
2:10607
3:10808

1:10809
2:11010
3:11210
.
.
.



Regards,

Dave

Footnote:
The MsTimer2 library functions are good certain things, but they hide some important information.  Namely that you are now dealing with interrupts, and things in the "callback" function that you give to Timer2::set() can affect lots of other things in meaningful ways that we might not have known about when we started.

Bottom line: Libraries like MsTimer2 are tools that have been crafted and shared so that some of us won't have to deal with the intricacies of timer registers and other somewhat arcane details of the processor.  The downside is that, by protecting us from having to know this to get started, it also may lead us into unknown territory through which we will, somehow, have to learn to navigate.  In particular, it has hidden from us the fact that the function that we give it will be executed as part of the timer's overflow interrupt service routine.

That's pretty much a valid description for the entire Arduino Way:  Easy to get started without having to learn a lot of the details that people are usually exposed to in programming classes.

It's kind of like learning to ride a bike with training wheels.

But...

After leaving the simple examples and simple applications behind, we may want to have more fun than is possible with the kid's bike.  The training wheels eventually may have to come off and we may actually need to learn more than we thought we did.

By that time, of course, we are hooked.  There is no turning back once our creative juices have started flowing and we can actually see some fun uses for this stuff.
2  Using Arduino / Programming Questions / Re: Error: invalid use of void expression on: July 11, 2011, 03:31:59 pm
The problem here is you need to pass the function name, not a value (that is, the function name IS the value required here).
I'm with you so far.  A function name by itself (no parentheses) is treated by the compiler as a pointer whose value is the address wherever the function is loaded. ("Normal" programmers don't need to know the actual value of the pointer; just use the name of the function where it is needed.)

Quote from: David Pankhurst
Do this
Code:
MsTimer2::set(5000, blinks);
And it should compile
No, it won't.  Did you try it?  (See Footnote.)

The second parameter of MsTimer2::set() is a pointer to a function that has no parameters, and the compiler won't let you give it a pointer to a function that takes two parameters.  Period.  Full stop.


Regards,

Dave

Footnote:
Suppose you could somehow (by hook or crook) get the compiler to accept the function name "blinks" as the second argument to the MsTimer2::set() function?  How the heck would it know what values to use for the time and amount arguments when invoking the function?  I mean, really!

Bottom line: One approach might be to build a working solution patterned after the suggestion in reply number 5 of this thread.  There are other ways...

3  Using Arduino / Programming Questions / Re: Error: invalid use of void expression on: July 10, 2011, 08:04:04 am
Maybe something like the following:

Code:
int blinksX;
int blinksY;

void blinksXY(void)
{
    blinks(blinksX, blinksY);
}
void blinks(int time, int amount)
{
// Your blinks code here
}


void loop()
{
.
.
.
        blinksX = 20;
        blinksY = 50;
        MsTimer2::set(5000, blinksXY);
 .
.
.

That way, you don't have to modify the library, and your blinks() code could be used in its "normal" way in other parts of your program.


Using globals in the body of the blinksXY() function is frowned on from a software engineering point of view, but lots of things we do in embedded systems like Arduino wouldn't stand up to a design review from my boss.  (She would insist on rewriting MsTimer2 as a template class and using a functor.  Stuff like that.)

Oh, well...


Regards,

Dave
4  Using Arduino / Programming Questions / Re: While loop questions. on: July 06, 2011, 06:40:24 pm
This should do it.


No, it won't.  If the value of steps1 is not equal to the value of steps2, it's an infinite loop.  (Why not test it?)

Maybe something along the lines of
Code:
void setup()
{
    Serial.begin(9600);
}
void loop()
{
    int steps1 = random(1,10);
    int steps2 = random(1,10);
    Serial.print("Calling doublestep(");
    Serial.print(steps1);
    Serial.print(",");
    Serial.print(steps2);
    Serial.println(")");
    doublestep(steps1, steps2);
    delay(10000);
    Serial.println();
}

void doublestep (int steps1, int steps2)
{
    while (steps1 || steps2) {
        if (steps1) {
            Serial.print("steps1 = ");
            Serial.println(steps1);
            --steps1;
        }
        if (steps2) {
            Serial.print("steps2 = ");
            Serial.println(steps2);
            --steps2;
        }
    }
}

Where for test purposes I just printed out the steps.  (And I gave enough delay between passes that you might be able to count them each time.)


Regards,

Dave

Footnote:
This would move motors 1 and 2 together until one of them had moved far enough, and the other would continue moving until it was finished.

A more interesting programming problem (and, maybe a more elegant and better-behaved machine) might be to distribute the moves as equally as possible between the two motors.  A recent thread mentioned one possible approach, but I haven't tried it.  (I think I could brute-force it with simple integer arithmetic rather than lisp-like lists, but...)

For all of you folks who think you wish the developers had chosen something other than C++ as the base language for Arduino, look at the example given in one of the references and rejoice (or not) that they didn't choose Lisp!


5  Using Arduino / Programming Questions / Re: Serial not declared in this scope. on: July 04, 2011, 03:28:40 pm
For recent versions of Arduino, the Arduino-type include file you need outside the main sketch is "WProgram.h" and this goes before any Arduino-stuff.

So...

Edit the following library files:

TwitterParser.h
Code:
#ifndef _TwitterParser_h
#define _TwitterParser_h

#include "WProgram.h"          // <--- Put this here
#include "HtmlParser.h"
//#include "HardwareSerial.h"  // <--- Don't need this
.
.
.


WiFly.h:
Code:
#ifndef _WiFly_h
#define _WiFly_h

#include "WProgram.h"          // <--- Put this here
//#include "HardwareSerial.h"  // <--- Don't need this
.
.
.

WorldMood.h:
Code:
#ifndef _WorldMood_h
#define _WorldMood_h

#include "WProgram.h"         // <--- Put this here
//#include "HardwareSerial.h" // <--- Don't need this
.
.
.

LED.h:
Code:
#ifndef _LED_h
#define _LED_h

#included "WProgram.h"        // <--- Put this here
//#include "HardwareSerial.h" // <--- Don't need this
.
.
.


Regards,

Dave

Footnote:
If you look in the Arduino core header file WProgram.h you can see that it includes the standard C library headers <stdlib.h>, <string.h>, <math.h> and some other stuff.  It is redundant to include <string.h> in the main program sketch (or anywhere else where WProgram.h has been included).  It's not "wrong" to include <string.h> (or <stdlib.h> or <math.h>), but I don't like a bunch of superfluous program statements cluttering up the landscape.  (But maybe that's just me: I'm funny that way.)

A final note: The Arduino IDE takes care of including "WProgram.h" before the code in your main sketch, so you don't need it there, but you need it in any library files (or "tab" files in your project) that use Arduino-specific types or functions or classes or objects or whatever...
6  Using Arduino / Programming Questions / Re: Code structure to define a class and then to instantiate? on: July 04, 2011, 10:41:15 am
...so to define a class one has to create a library ...

Here's the thing:

Put all of the .h and .cpp class files in the same directory as your main sketch.  They will appear as "tabs" the next time you open the Arduino IDE and open that sketch.  You can examine and edit the .cpp and .h files by clicking their tabs.  If you include the .h file(s) in your main sketch, Arduino can compile and link everything together.

If you put the .cpp and .h files in a libraries subdirectory, you can import them into any sketch, but you can not open them for examination or modification from within the Arduino IDE.

Bottom line: When developing a library, it may be more convenient to use tabs in a particular sketch.  If you want to use that class (or those classes) in any other sketch, copy them into a libraries subdirectory so that you can "import" them from the Arduino IDE.

Regards,

Dave
7  Using Arduino / Programming Questions / Re: Splitting code into different classes and files? on: July 04, 2011, 09:35:20 am
...
Can I create a bunch of something.h and something.cpp files in that directory

Yes.  That's the ticket for "normal" Arduino operation.  All .h and .cpp files that are in the same directory as the main sketch .pde file will appear as "tabs" in the Arduino IDE, and you won't have to fake out Arduino.  Arduino will compile and link without having to do anything special

This may not be the ideal file organization for sizable projects, but being able to use standard Arduino procedures means that you can port the code to other environments without having to change anything in the Arduino preferences file.  (That means that you can ask for help or code reviews from other people who can run your stuff in their "normal" Arduino setups.)

Regards,

Dave
8  Using Arduino / Networking, Protocols, and Devices / Re: UDP & NTP Woes on: July 03, 2011, 04:35:19 pm
I gave a link for a dhcp/dns library that works with arduino-0022 Here: http://arduino.cc/forum/index.php/topic,63891.0.html.

With dhcp, I get ip address from the dhcp server on my LAN.  With dns, I get ntp time from pool.ntp.org.

[/Begin disclaimer]
I am using Arduino Ethernet shields designed around the Wiznet 5100 chip.  As far as I can tell, the same stuff should work with the Wiznet module that you have, but I have no way of testing.
[/End disclaimer]

Regards,

Dave

9  Using Arduino / Programming Questions / Re: arduino serial running @ 250bps on: July 03, 2011, 12:51:56 pm
    
...
To get 250 bps you'd use UBRR0 = 16 Mbps/(16 * 250 bps)-1 which is exactly equal to 4000.
Well, to get picky, the register value would be 3999, which would result in a rate of exactly 250 bps if the Arduino clock is exactly 16 MHz.


But to answer the Original Poster's question: For Arduino version 22, if your board is running with a 16 MHz clock, the HardwareSerial::begin() function will use "2X" UART mode for that setting, and I believe that Serial.begin(250) will not work since it would require a 13-bit number in ubrr0. In fact, it looks to me as if any settings below 489 will try to load the baud rate register with something larger than a 12-bit number.

I think a simple modification to HardwareSerial.cpp will the trick.  With arduino-0022 I have verified that, with a CPU clock of 16 MHz, 300 baud settings do not work without modification.

Here's my suggestion for a modified HardwareSerial::begin() function in that file:

Code:
void HardwareSerial::begin(long baud)
{
  uint16_t baud_setting;
  bool use_u2x = true;

#if F_CPU == 16000000UL
  // hardcoded exception for compatibility with the bootloader shipped
  // with the Duemilanove and previous boards and the firmware on the 8U2
  // on the Uno and Mega 2560.
  if (baud == 57600) {
    use_u2x = false;
  }
#endif
  
  // Beginning of modified code, suggested by davekw7x
  if (use_u2x) {
    *_ucsra = 1 << _u2x;
    baud_setting = (F_CPU / 4 / baud - 1) / 2;
    if (baud_setting > 0xfff) { // ubrr is a 12-bit register
      use_u2x = false;
    }
  }
  if (!use_u2x) {
    *_ucsra = 0;
    baud_setting = (F_CPU / 8 / baud - 1) / 2;
  }
  // End of modified code

  // assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
  *_ubrrh = baud_setting >> 8;
  *_ubrrl = baud_setting;

  sbi(*_ucsrb, _rxen);
  sbi(*_ucsrb, _txen);
  sbi(*_ucsrb, _rxcie);
}

Verified (with minicom and with Arduino serial terminal) for common baud settings from 300 through 115200 with Arduino Uno and Duemilanove boards operating with F_CPU = 16000000.  (See Footnote.)

I believe that it should work for 250 baud, but I have no way of testing just now.


Regards,

Dave

Footnote:
For me, "common" rates are the following: 300, 1200, 2400, 4800, 9600, 19200, 38400, 57600, and 115200.  Note, particularly that the Arduino Serial Monitor 14400 and 28800 settings are not usable on my Linux system, and, in fact if I select either of these two, Bad Things happen that make me have to manually edit the serial.debug.rate entry in my .arduino/preferences.txt file to be able to use the Arduino IDE to do any more uploads.

10  Using Arduino / Programming Questions / Re: The difference between #define and const on: July 02, 2011, 11:10:45 am
Since I am arriving at the party a little late, I won't bother responding to previous guesses (erroneous or not).  I'll just reply to the most recent post.

Does const int const put into ROM or initialised in RAM at startup?

It's in the instruction itself, not in a separate variable space in memory anywhere.

Here's the thing:

For programs compiled with avr-gcc optimized for space (which is what Arduino does), values of variables designated "const" are put directly into the code.  So it costs nothing at run-time to use the const... thingie.  (Note that this action is not part of any C or C++ language standard, and it is not absolutely, positively, unequivocally guaranteed that this will be the case with all compilers or even all versions of avr-gcc, but it is my observation using avr-gcc version 4.3.4 with arduino-0022 on my Linux system.)

Anyhow, for purposes of illustration (and confirmation of my observation), let's take the world-famous Arduino "Blink" sketch.

Compile using 13 everywhere the LED pin is referred to. (That's the way it is in my version of arduino-0022/examples/1.Basics/Blink.pde)

Then use #define ledPin 13 at the top of the sketch and change all occurrences of "13" to "ledPin" and compile again.

Of course you will get the exact same code, right?  I mean, that's what #define is all about, right? (Don't take my word for it---try it.)

Now use const int ledPin = 13; instead of the #define.  Compile again.  I get the same code.  Exactly the same.  Therefore I conclude that there is no "penalty" for using the more robust construct for this example with this compiler and this version of Arduino.  (See Footnote.)

Now, as has been mentioned, in general, using a "const variable" instead of #define can give the compiler some additional error checking capabilities, since type checking can be performed on usage of the "const variable"  This can be a Very Good Thing since it can help the compiler find some of our usage errors.

The main other difference (to me) is that the variables designated "const..." appear to the compiler to be just like variables (except, of course, the user program won't be allowed to change the value at run time).

That means, for example, if you have a function that takes a pointer as an argument, you can send it the address of the "const variable," but you would not be able to do this with a #defined identifier.

Code:
// To see the difference between a "constant variable" declaration and
// a #define, comment out the next line and uncomment the one after it.
const int bar = 42;
//#define bar 42

void setup()
{
    // Whatever
}

void loop()
{
    int xyz[3] = {1, 2, 3};
    foo(&bar); // The address of the "constant variable"
    foo(xyz);  // The address of xyz[0];
    //
    //whatever else you want to do
    //
    
}

void foo(const int *x)
{
    // Do something with whatever it is that "x" is pointing to
}

Now, for programs like this last example, it's not a matter of whether there is some memory allocated (somewhere) for the "const int" identifier.  (There is.)  It's a matter of whether you can do the same thing with a #define statement. (You can't).


But this all probably not interesting to the original poster...!

Maybe this isn't such a BFD for beginners, but I think it is interesting and, maybe, even useful...



Regards,

Dave

Footnote:
When I said that I got the "exactly the same code," I don't just mean that I got the same sketch size.  I examined the results of executing avr-objdump -d on the generated .elf files in the Arduino build directory.  A "diff" showed no differences at all among the three cases of blink sketch that I mentioned above.

Here's the disassembled code for the loop() function for all three versions. The "ldi r24, 0x0D" instructions are the places where the compiler is using the value of ledPin.
Code:
000000ea <loop>:
  ea: 8d e0       ldi r24, 0x0D ; 13
  ec: 61 e0       ldi r22, 0x01 ; 1
  ee: 0e 94 e2 00 call 0x1c4 ; 0x1c4 <digitalWrite>
  f2: 68 ee       ldi r22, 0xE8 ; 232
  f4: 73 e0       ldi r23, 0x03 ; 3
  f6: 80 e0       ldi r24, 0x00 ; 0
  f8: 90 e0       ldi r25, 0x00 ; 0
  fa: 0e 94 85 01 call 0x30a ; 0x30a <delay>
  fe: 8d e0       ldi r24, 0x0D ; 13
 100: 60 e0       ldi r22, 0x00 ; 0
 102: 0e 94 e2 00 call 0x1c4 ; 0x1c4 <digitalWrite>
 106: 68 ee       ldi r22, 0xE8 ; 232
 108: 73 e0       ldi r23, 0x03 ; 3
 10a: 80 e0       ldi r24, 0x00 ; 0
 10c: 90 e0       ldi r25, 0x00 ; 0
 10e: 0e 94 85 01 call 0x30a ; 0x30a <delay>
 112: 08 95       ret

I hate to repeat myself, but there is no guarantee that the resulting executable code will always be the same for the different cases.  If people have different results, maybe they can share them with us.  (Be sure to tell us what version of avr-gcc you are using, and what version of Arduino---I don't know for sure that they have always used the same optimization switches with the same effect that I reported here.)
11  Using Arduino / Programming Questions / Re: progmem function on: July 01, 2011, 01:38:23 pm
...is spitting out every string in progmem all at once...
If you want it to print one line, why are you calling a function that tells it to print not only a given line but all of the lines after that one?  (See Footnote.)


Maybe you can try:
Code:
void loop()
{
    printPgmLine(1, no_line);
    Serial.println("21");
    printPgmLine(2, no_line);
    Serial.println("40000");
    printPgmLine(3, no_line);
    Serial.println("50");
    delay(3000);
}

void printPgmLine(int string_num, int ln)
{
    char write_buffer[44];
    strcpy_P(write_buffer, (char *)pgm_read_word(string_table + string_num));
    Serial.print(write_buffer);
    if (ln) {
        Serial.println();
    }
}

Or some such thing.


Regards,

Dave

Footnote:
The "speak" function that you showed us has undefined behavior since the loops can try to access memory beyond the end of the array of strings.  
12  Using Arduino / Programming Questions / Re: generation of 40kHz square wave using PWM on: July 01, 2011, 12:28:25 pm
actually i wanted to generate 40kHz square wave to be given...
If I thought I could explain it better than the awesome Mr. Sharriff, I might try.  Alas, I don't think I can accomplish that.  Maybe someone else here feels like giving it a shot.

If you are interested in learning, you can check his code, as I suggested.  In particular:

Code:
void IRsend::enableIROut(int khz) {
  // Enables IR output.  The khz value controls the modulation frequency in kilohertz.
  // The IR output will be on pin 3 (OC2B).
  // This routine is designed for 36-40KHz; if you use it for other values, it's up to you
  // to make sure it gives reasonable results.  (Watch out for overflow / underflow / rounding.)
  // TIMER2 is used in phase-correct PWM mode, with OCR2A controlling the frequency and OCR2B
  // controlling the duty cycle.
  // There is no prescaling, so the output frequency is 16MHz / (2 * OCR2A)
  // To turn the output on and off, we leave the PWM running, but connect and disconnect the output pin.
  // A few hours staring at the ATmega documentation and this will all make sense.
  // See my Secrets of Arduino PWM at http://arcfn.com/2009/07/secrets-of-arduino-pwm.html for details.
.
.
.

The "IR output" to which he is referring is, simply, a square wave on Arduino pin 3.  Use it for whatever you want to.  He also shows how to turn the output signal on and off with a single instruction (without starting and stopping the timer each time), so it can be useful for lots of stuff.  Maybe even your application.

If you have specific questions, I'm betting that someone here is willing and able to try to help...



Regards,

Dave


13  Using Arduino / Programming Questions / Re: How can I create a 2MHz frequnecy on: July 01, 2011, 11:56:26 am
I´ve copied this code from the forum:
You're welcome.  (See Footnote.)


Quote from: ref110
Can  someone change the code that I have a 2MHz output on an other pin.

How about Pin 3?
Code:
const int freqOutputPin = 3;  
const int ocr2aval  = 3;

// These are not needed to generate the code.  They are simply to remind the user
// what the frequency is.  Note that changing the value of "prescale" here does
// not affect the counter operation.  It's just for the printout vlaue
const int prescale  = 1;
const float period    = 2.0 * prescale * (ocr2aval+1) / (F_CPU/1.0e6);
const float freq      = 1.0e6 / period;

void setup()
{
    pinMode(freqOutputPin, OUTPUT);
    Serial.begin(9600);
 
    // Toggle OC2B on "compare match".
    // Normal count mode with OCRA as "top"
    TCCR2A = ((1 << WGM21) | (1 << COM2B0));

    // Prescale divider value = 1
    // If you want to change the prescale value, look at the ATmega
    // data sheet for the appropriate values of CS22:0
    //
    TCCR2B = (1 << CS20);

    // Not really needed here, since TIMSK is initialized
    // to zero, but for general use, it's probably not
    // a bad idea to make sure timer 2 interrupts are
    // disabled.
    TIMSK2 = 0;
  
    // This is the "top" value at which the counter will reset
    OCR2A = ocr2aval;

    Serial.print("Period    = ");
    Serial.print(period);
    Serial.println(" microseconds");
    Serial.print("Frequency = ");
    Serial.print(freq);
    Serial.println(" Hz");
}

// Timer 2 Output is directly connected to the designated OCR pin, so
// program intervention is not required to do anything with it.
//
void loop(){
    //
    // Do just about anything you want to here, but if you mess
    // with Timer 2, you may affect the output on its OCR pin.
    //
}

Tested on ATmega 328 Arduino boards.


Regards,

Dave

Footnote:
We contribute to the forum in hopes that people can learn from the code.  Because of the power and versatility of the timer functions on ATmega chips (and, therefore, the complexity), it's hard for most of us to wade through the data sheet.  That's why I sometimes post complete programs.  (And I always test any complete programs that I post.)

If people (even beginners) are really interested, they can go back through the data sheet and, maybe, see why these registers are set up like this.  Maybe the few comments that I put here will help.  There were more comments in http://arduino.cc/forum/index.php/topic,62964.0.html.  Sometimes my propensity for wordiness confuses people, or maybe it just wears them down.

Oh, well...
14  Using Arduino / Programming Questions / Re: generation of 40kHz square wave using PWM on: July 01, 2011, 11:11:40 am
Can i generate 40kHz square wave using PWM of Arduino??

Ken Sharriff's excellent IRremote library has a function that can create and modulate a 40 KHz square wave on Arduino pin 3 (using Timer 2) for driving an IR LED to talk to IR Remote devices.

If your application is something else, you still might benefit from looking at the code to see how he does it.


Regards,

Dave
15  Using Arduino / General Electronics / Re: Building a frequency divider.. need some help with a symbol on: July 01, 2011, 10:31:16 am
...create the pdf schematic?
I am using Cadsoft Eagle Version 5.1, which has an option to print to a PDF file.

Earlier versions did not have that, and I used Acrobat Distiller as print target to create documentation for distribution.  (The pdf files from Eagle are smaller than what I used to get from Acrobat.)

Regards,

Dave
Pages: [1] 2 3 ... 50