Hi,
I am trying to generat a 125kHz square wave. I am not sure how to test if pin 11 is outputing the same. How do I do that?Newbie here. Forgive the number of comments. It's a test program.
/******* Sketch to test Input Capture interrupt handling ***********************/
#include <stdio.h>// for verbose debugging using sprintf
#include <avr/io.h>
#include <avr/interrupt.h>
//#include "TimerOne.h"
//#include "Timer.h"
#include "PWM.h"
#define icpPin 8 //ICP input pin on arduino - DATA IN HERE.
#define pwmoutPin 11 // OCR1A pin on arduino
//#define outPin 9 // output pin that will shadow the input, can be monitored with a scope
//#define outPin 9
volatile uint8_t rising;
unsigned long currentMicros;
unsigned long previousMicros;
unsigned long elapsedMicros;
unsigned long Period = 8000000UL; // overall period
// pick the high time, calculate the low time from what's left
unsigned long highPeriod = 4000000UL; // microseconds, x 2 = 10mS = 100 Hz
// probably best if times are increments of 4uS to match up with micros()
unsigned long lowPeriod; // microseconds, set to = Period - highPeriod in setup()
byte highTime;
// some variables to help see that something is happening in the interrupt handlers
volatile unsigned int Value; // this stores the current ICR1 value
//volatile unsigned int MinValue;
//volatile unsigned int MaxValue;
volatile unsigned int Overflows;
volatile unsigned int PulseCount;
unsigned long duration;
//int32_t frequency = 125000
char in_buffer[800];
short i;
//Timer t;
/* Overflow interrupt vector */
ISR(TIMER2_OVF_vect){ // here if no input pulse detected
Overflows++; // incriment overflow count
}
/* ICR interrupt vector */
ISR(TIMER2_CAPT_vect){
TCNT1 = 0; // reset the counter
OCR1B = 0; //data
//catchRisingEdge();
/*if( bit_is_set(TCCR1B ,ICES1)){ // was rising edge detected ?
digitalWrite(outPin,HIGH ); // yes, set our output pin high to mirror the input
}
else { // falling edge was detected
Value = ICR1; // save the input capture value
digitalWrite(outPin,LOW ); // set our output pin low to mirror the input
PulseCount++;
}/*if(Value < MinValue) // update min or max values as appropriate
MinValue = Value;
if (Value > MaxValue)
MaxValue = Value;
} */
TCCR1B ^= (1<<ICES1); // toggle bit value to trigger on the other edge
if(bit_is_set(TCCR1B, ICES1)){
catchRisingEdge();
Value = OCR1B;
digitalRead(pwmoutPin);
}
else{
catchFallingEdge();
Value = OCR1B;
digitalRead(pwmoutPin);
PulseCount++;
}
/*if(bit_is_set(TCCR1B, ICES1)){
digitalWrite(OUT, HIGH);
}
else{
Value = ICR1;
digitalWrite(OUT, LOW);
PulseCount++;
}*/
/* static byte lastEdge;
byte thisEdge = ICR1;
byte difference = lastEdge - thisEdge;
if (difference
lastEdge = thisEdge; */
}
/*ISR(TIMER0_COMPA_vect){
if(i<800){
buffer[i] = digitalRead(icpPin);
}i++;
}*/
//int val = 0;
//int ledPin = 11;
//int analogPin = 3;
//int pwmPin = 9;
//const int16_t TOGGLE_TIME = 8;
void setup() {
Serial.begin(9600);
//pinMode(outPin, OUTPUT); // declare the ledPin as an OUTPUT
//pinMode(icpPin, INPUT); // ICP pin (digital pin 8 on arduino) as input
//MinValue = 30000; // Initialise with extreme values
//MaxValue = 0;
//SetPinFrequency(9, 125000);
DDRB |= (1<<PINB5);//|(1<<PINB6); //OC1A and OC1B on arduino Pin 11 and Pin 12.
pinMode(11, OUTPUT);//125kHz carrier generated here
pinMode(8, INPUT_PULLUP);
//digitalWrite(9, HIGH);
//delayMicroseconds(8);
//digitalWrite(9, LOW);
//delayMicroseconds(8);
//Timer1.initialize(8);
//Timer1.pwm(9, 512);
/*digitalWrite(9, HIGH);
delayMicroseconds(8);
digitalWrite(9, LOW);
delayMicroseconds(8);*/
//USE FAST MODE TO ENABLE DOUBLE BUFFERING - GIVES A GLITCH FREE OUTPUT
//TCCR1A |= (0<<COM1A1)|(1<<COM1A0) ; //Toggle on reaching OCRA // this register set to 0!
//TCCR1A |= (1<<WGM10);
TCCR1A = (1<<COM1A1)|(1<<COM1A0)|(1<<COM1B1)|(1<<COM1B0)|(0<<WGM11)|(1<<WGM10);
TCCR1B = (1<<ICNC1)|(1<<ICES1)|(0<<WGM13)|(1<<WGM12)|(0<<CS12)|(1<<CS11)|(1<<CS10); //250kHz; prescaler 64; Set to Fast PWM Mode - 8 bit; enable noise canceller; enable input capture
OCR1A = 127;
OCR1B = 0;
TCNT1H = 0;
TCNT1L = 0;
TIMSK1 = (1<<ICIE1)|(1<<TOIE1); // enable input capture interrupt for timer// enable overflow interrupt to detect missing input pulses
/*
TCCR2A |= (1<<WGM21);
TCCR2B |= (1<<CS22)|(1<<CS21);
OCR2A = 1;
TCCR0A |= (1<<WGM01);
TCCR0B |= (1<<CS02) | (1<<CS00);
OCR0A = 1;*/
//currentMicros = micros();
//previousMicros = currentMicros;
//lowPeriod = Period - highPeriod;
Serial.print("Finished setup\r\n");
Serial.println(in_buffer);
Serial.println(Value);
}
//long lastTime;
//int dataState = 0;
short j;
void catchRisingEdge() {TCCR1B |= (1<<ICES1); TIFR1 |= (1<<ICF1); rising = 1;}
void catchFallingEdge() {TCCR1B &= ~(1<<ICES1); TIFR1 |= (1<<ICF1); rising = 0;}
// this loop prints the number of pulses in the last second, showing min and max pulse widths
void loop() {
while(1){
for(i=0; i<800; i++){
in_buffer[i] = digitalRead(8);
}}
//Serial.print(in_buffer);
/*for(j=0; j<800; j++){
Serial.print(in_buffer[j]);
}}*/
/*currentMicros = micros();
elapsedMicros = currentMicros - previousMicros;
if (highTime == 1 && elapsedMicros >= highPeriod) {
PINB = PINB | 0b00000011;
previousMicros = previousMicros + lowPeriod;
highTime = 0;
}
if (highTime == 0 && elapsedMicros >= lowPeriod) {
PINB = PINB | 0b00000011;
previousMicros = previousMicros + highPeriod;
highTime = 1;
}*/
//char buffer[800];
// show the captured data, divide pulse widths by 2 to display time in microseconds
//sprintf(buffer,"Got %d pulses: min=%d, max=%d (%d timer overflows)\r\n", PulseCount, MinValue / 2, MaxValue / 2, Overflows);
//SetPinFrequency(9, 125000);
//on();
// digitalWrite(OUT, HIGH);
// delay(8);
// digitalWrite(OUT, LOW);
// delay(8);
//off();
//int val = digitalRead(9);
/* uint8_t state = 0;
while(1) {
if(state == 0) {
digitalWrite(9, LOW);
state = 1;
delay(8);
catchRisingEdge();
//Serial.println(state);
//Serial.println(rising);
}
else {
digitalWrite(9, HIGH);
state = 0;
delay(8);
catchFallingEdge();
//Serial.println(state);
//Serial.println(rising);
}}*/
//Serial.println(rising);
//duration = pulseInLong(9, HIGH);
//Serial.println(duration);
//value = pulseIn(9, HIGH);
/*
int analogValue = analogRead(9);
int newdataState = (analogValue > 600);//need to check, hoping boolean will evaluate to 1 when true
if(dataState == 0 && newdataState == 1){//if the led was off, but will be turned on, start the stop watch
lastTime = millis();//store the current time
dataState = newdataState;
}
if(dataState == 1 && newdataState == 0){//if the led was on, but will be turned off, get the difference between the last time we started counting time
long difference = millis() - lastTime; //get the current time, but subtract the last stored time
dataState = newdataState;
Serial.println(difference);
}
digitalWrite(9,dataState);*/
/*
while(1){
if
}*/
/*/////////////////////////////////////////////*/
/*static uint16_t last_toggle;
if ((uint16_t) micros() - last_toggle >= TOGGLE_TIME) {
PINB = _BV(PB1); // invert pin state
last_toggle += TOGGLE_TIME;
}
Serial.println(last_toggle); */
/*///////////////////////////////////////////////////////*/
//Serial.println(val);
//val = analogRead(pwmPin);
//analogWrite(ledPin, val/4);
//Serial.println(val);
//Serial.print(buffer); // send the info to the serial port
/* reset variables ready for the next reading */
/*PulseCount = Overflows = 0; // reset counts
MinValue = 30000; // set values to extremes
MaxValue = 0;
delay(800); */ // wait 1 second for next update [/font]
}
/*
void takeReading(){
int val = digitalRead(9);
val++;
Serial.println(val);
}
*/
..i did..it's printing trash.