I'm pretty new to arduino, so some of the stuff I'm working with I don't really understand. I've been lucky thus far...but I think I need some help now.
I'm trying to get a pin to turn HIGH for 4.5-6 microseconds, and LOW for 1595 microseconds...and just repeat. Eventually I want to be able to make that happen only when I get a serial input from processing, but I think that's just an if() statement I need to add later.
My problem is that if I use the technique described in "blink without delay" except for with micros() instead of millis() then (according to what I've read about micros) I can only operate in intervals of 4 microseconds. 4 is too little, and 8 is too much. So, I figured that maybe I could just use that technique for the long off interval, and put a "delay" in there for the 5 microsecond ons (how much could a 5 microsecond break from my code really hurt?)
Is there a way do to this without delay?
I'm also using the "regulated voltage booster" code to get raise my power, and I think that because it does some stuff with the watchdog timer thing (not very knowledgeable on that subject) that it is making it so that I can't properly use the delay function. I tried a test with millis() instead of micros() (so I can see how things are working) on pin 13...and instead of blinking on and off at the right pace, it just blinks really really fast. I tried to keep this short for the sake of not making you read a huge story...but if I can give you any more info, please let me know. Any help would be very much appreciated. My code is below with the millis() that is making things blink really fast when I use delay (should be two seconds off, one on).
#include <wiring_private.h>
// included for access to cbi(), sbi() macros, and TCCR1B register definitions
#include <avr\wdt.h>
#undef int
#undef abs
#undef double
#undef float
#undef round
// access to watchdog timer macros
unsigned int power_level = 0;
// The target regulated voltage, default power level 0V (output will be input voltage +/-1V)
// Do not change this definition (change the SetVoltage(v) assignment in setup, below)
unsigned int SetVoltage(double voltage);
// Calculate the desired analog input reading, for a given voltage
signed int duty = 0; // used in the main program loop
// it's assigned to the analog output, to control the output voltage.
// the relationship between duty cycle and voltage depends on output load and input voltage.
// since neither the load or input are assumed, the program estimates/seeks
// the correct duty cycle by sensing the output voltage and making small adjustments.
// A greater duty cycle makes a greater voltage.
//alternate names which link arduino pins to where they go
int c1 = 2;
int c2 = 3;
int c3 = 4;
int c4 = 5;
int c5 = 6;
int c6 = 7;
int c7 = 8;
int c8 = 9;
int c9 = 11;
int c10 = 12;
int c11 = 13;
int c12 = 19;
int value = LOW; //previous value of the pin
long previousCount = 0; //stores the value of the fired pin
//long firetime = 5; //the amount of firing time in microseconds
//long interval = 1595; //the amount of time between firings in microseconds
long firetime = 1000; //the amount of firing time in milliseconds
long interval = 2000; //the amount of time between firings in millisecond
void setup() {
// I use pin 13 to indicate power, with an LED. (like the older revisions had built-in)
// For my rev.c arduino, I put an LED between pin 13 and GND (outputs only source 20mA).
pinMode(19,OUTPUT);
pinMode(13,OUTPUT);
pinMode(12,OUTPUT);
pinMode(11,OUTPUT);
pinMode(9,OUTPUT);
pinMode(8,OUTPUT);
pinMode(7,OUTPUT);
pinMode(6,OUTPUT);
pinMode(5,OUTPUT);
pinMode(4,OUTPUT);
pinMode(3,OUTPUT);
pinMode(2,OUTPUT);
//digitalWrite(c2,HIGH);
// The following code increases the PWM frequency
// This might have an effect on delay(n) and millis() functions.
// The ideal frequency depends on the inductor, but it'll only be important if you need alot more power.
// My earlier tests indicated 20-300KHz are usable (depending on the inductor).
// (If 1KHz is used, the inductor will make a buzzing sound.)
#if defined(AVR_ATmega168) || defined (AVR_ATmega328P)
// 62.5KHz PWM for the ATMega168 -> only on Arduino pins 9 and 10
// set prescaler to 1
// (sbi means "set bit register", cbi means "clear bit register")
cbi(TCCR1B, CS12);
cbi(TCCR1B, CS11);
sbi(TCCR1B, CS10);
// set fast PWM
cbi(TCCR1B, WGM13);
sbi(TCCR1B, WGM12);
// with fast PWM, the frequency is (CLK/256*prescaler) = 16MHz/256 = 62.5KHz
// with slow PWM, it is half that speed (31KHz)
#else
// 22KHz for the ATMega8 (this is a low frequency, so fewer inductors might work with it)
TCCR2 = ((TCCR2 & ~0x07) | 0x01);
TCCR1B = ((TCCR1B & ~0x07) | 0x01);
#endif
// enable the watchdog timer (a failsafe reset: if the program freezes, the voltage booster will shut off)
// the Arduino will reset if this timer isn't cleared in less than 400ms.
wdt_enable(400);
// set the voltage you want the program to maintain (any decimal value greater than your input voltage)
power_level = SetVoltage(22.0);
// Do not exceed 24V without taking special precautions.
// Do not exceed 60V with the circuit/schematic provided with this software. (75V or more will damage the arduino)
// Do not exceed 250mW (aka 1/4W, aka quarter watt) of power. (MAX: 5V 50mA, 9V 28mA, 12V 21mA, 24V 10mA, 48V 5mA)
}
void loop() {
unsigned int measure = analogRead(0);
wdt_reset(); // watchdog timer reset (see above)
if (measure>power_level+18) {
// "panic" if the measured voltage is more than 1V above where it should be,
// cut power by 50% to respond quickly.
duty=duty/2;
} else if (measure>power_level) {
// decrease duty cycle to compensate for smaller load
duty=max(0,duty-1);
} else if (measure<power_level) {
// increase duty cycle to compensate for larger load
duty=min(191,duty+1);
// Without the 191 limit, it can cause regulation to fail at high loads or high voltages.
// Only modify this limit if you're using an improved version of the schematic I've given.
} else {
return;
}
analogWrite(10,duty);
// If you have HF noise problems, you might want to add a small microseconds delay here to see if it helps.
// Delays can make voltage regulation worse, by reacting slower to changes in the output load.
// If you have regulation problems, make sure your output filter capacitor is at least 0.1uF.
// As your circuit's load changes, the capacitor will slow down output fluctuations.
//if (micros() - previousCount > interval) {
// previousCount = micros(); //recall the last time a pin was fired
if (millis() - previousCount > interval) {
digitalWrite(c11, HIGH);
//delayMicroseconds(firetime);
delay(1000);
digitalWrite(c11, LOW);
previousCount = millis(); //recall the last time a pin was fired
}
}
// Calculate the desired analog input reading, for a given voltage
unsigned int SetVoltage(double voltage) {
if (voltage>60) {
return 0; // do not exceed 60V
}
// This function converts the voltage value (0 to 5V reading; 0 to 60V actual), into a value for an analog input (from 0 to 1024)
// If your resistor voltage divider is not perfectly 15:1 you'll need to change the formula below
// with ideal resistors and a perfect 5V Analog Reference voltage (AREF), an analog input value of 13.65 would be 1V
return (voltage12.8);
// ideal ADC value, per volt = voltage(1024/5)/(15/1) = 13.65
// the real value for my circuit = voltage*(204.8)/(16.5) = 12.41
// 16.5 was my measured resistor voltage divier ratio.
// I increased my calculated 12.41 constant to 12.8, by trial and error, in order to get closer to the target voltage
// My results were +/-0.2V, at a 0.1mA (100Kohm) load when powered by the Arduino.
}