AVR Freaks

Thanks for the ideas. As for the data queue for the transmit buffer and <RS> <US>... maybe someone has done it before and I don't want to "reinvent things". Could you please refer me to well made codes? Or where i can find examples ?

Thank you very much !!! About links, first link have 404 error.

I dont know if i understand your idea properly. I add queue and  protocol (header,len,value,checksum) and something goes wrong. If you could verify where i do mistake or what shoud i do. Here is my code:

#include <avr/interrupt.h>
#include <avr/io.h>
#include <util/delay.h>
#include <util/atomic.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>

volatile uint16_t Tdiff;
static constexpr uint32_t UART_BAUD_RATE=57600;   
volatile uint16_t test = 6411;


typedef struct __attribute__((packed)) Message {

	uint16_t header;
	uint16_t len;	  
	uint16_t Nx;	   
	uint16_t checksum; 
	struct Message* next;
};


Message* head; 
Message* tail; 


void add_to_queue(uint16_t len, uint16_t Nx, uint16_t checksum) { 
Message* newElement;
    newElement = (Message*)malloc(sizeof(Message)); 

	newElement->header = 0x03;
	newElement->len = len;   
	newElement->Nx = Nx;
    newElement->checksum = checksum;
	newElement->next = NULL;
	if(head == NULL) { 
        tail = newElement;  
        head = newElement;  
    }
    else {
        tail->next = newElement; 
        tail = newElement;  
    }
}


void free_queue() { 
    if(head == NULL)
        return;

    Message* tmp;
    while(head->next != NULL) {
        tmp = head;
        head = head->next;
        free(tmp);
    }
    free(head);
    
    head = NULL;
    tail = NULL;
}


Message* pop_queue() { 
    Message* to_return = NULL;
    if(head == NULL) {
  
        return NULL;
    }
    
    if(head->next != NULL) {
        to_return = head;
        head = head->next;
    } else {
    
        to_return = head;
        head = NULL;
        tail = NULL;
    }
    return to_return;
}

uint8_t calc_checksum(void *data, uint8_t len)  // function to count checksum
{
  uint8_t checksum = 0;
  uint8_t *tmp;
  for(tmp = (uint8_t*)data; tmp < (data + len); tmp++){
                                                // xor all the bytes
    checksum ^= *tmp;                           // checksum = checksum xor value stored in tmp
  }
  return checksum;
}

void UARTSetup(uint32_t baudrate) {
  // UART settings:
  // * 8 data bits
  // * No parity bits (default)
  // * 1 stop bit (default)
  // * Asynchronous Normal mode (default)
  uint32_t const baseClockFrequency = F_CPU;
  uint32_t const uartClockDivider = 16;
  uint16_t const UBRRValue = static_cast<uint16_t>(
      (baseClockFrequency / (uartClockDivider * baudrate)) - 1);
  // Setup TX0 pin as output (PD1)
  DDRD |= _BV(PD1);
  // Set baudrate 
  UBRR0 = UBRRValue;
  // Enable transmitter
  UCSR0B |= _BV(TXEN0);
  // Set 8-bit frame format
  UCSR0C |=(1<<UMSEL01)|(3<<UCSZ00);
}
void UARTSendByte(unsigned char value) {
  // Wait until the previous transmission has ended
  while (!(UCSR0A & _BV(UDRE0)))
    ;
  UDR0 = value;
  // Put the data into buffer
}
void UARTSendBytes(uint8_t const* data, size_t length) {
  for (uint8_t const* ptr = data; ptr != (data + length); ptr++) {
    UARTSendByte(*ptr);
  }
}

void UARTSendValue(uint16_t value) {
  UARTSendBytes((uint8_t const*)&value, sizeof(value)); 
}
void UARTSendMessage(Message* message){
	UARTSendValue(message->header);
	UARTSendValue(message->len);
	UARTSendValue(message->Nx);
	UARTSendValue(message->checksum);
}

void ICTimerInit() {
 
  TCCR1B |= _BV(ICES1) | _BV(CS10);

  TIMSK1 |= _BV(ICIE1) | _BV(TOIE1);
}



ISR(TIMER1_CAPT_vect) {
	Tdiff = ICR1; 
}


ISR(TIMER1_OVF_vect) {

}

void NewData(){
	sei();
	
		Message *data = pop_queue();
		if (data!=NULL){

			UARTSendMessage(data);
			free(data);
		}

	cli();
}
int main() {
  cli();  
  resetSystemTimerPrescaler();
  UARTSetup(UART_BAUD_RATE);
  ICTimerInit();
  sei(); 
  
  while (true)
  {
    if(Tdiff){
	    add_to_queue(sizeof(Tdiff), Tdiff, calc_checksum(&Tdiff, sizeof(Tdiff)));
    }
	  NewData();

  }
    
}

Okay,so lets beginning. This code give me 10-15 messages and stuck. Sometimes wont send any message, another time send over 100 messages. Second problem is still missing data, i mean in struct sometimes example: head switch places with checsum or another paramer. Its looks like all value stepping each sending value or lose one and more bytes ( insted of constant values i see data with diffrent endiannes). Until then, I was also looking for information about the buffer in the Python library (the receiving application is written in this language using pyserial) and nothing came out. I also changed the baudrate in the device manager and that didn't help either.

     avrcandies wrote:

Who told you to use or??

Thanks for verifying. Truth is i learning this by myself and some examples what i found had this line. https://maxembedded.com/2013/09/.... Only (1<<UMSEL01) i added. Perhaps i did not understand it correctly.

UCSR0C =(0<<UMSEL01)|(0<<UMSEL00)|(3<<UCSZ00); 

This should be correct configuration for my device if i need asynchronous transmission ?

Thanks for the suggestion. I added your idea and still something goes wrong. I mean I'm getting some correct values (16005 timer 4 ticks at 1kHz const square signal) but still getting incorrect value as bouns. All data i capture with putty. Here is the graph from the calculations and the code again:

#include <avr/interrupt.h>
#include <avr/io.h>
#include <stdio.h>

volatile uint16_t Tdiff;
const uint32_t UART_BAUD_RATE=76800;
uint16_t test = 7411;
uint16_t val;

int uart_putchar(char c, FILE *stream);
static FILE mystdout = FDEV_SETUP_STREAM( uart_putchar, NULL, _FDEV_SETUP_WRITE );

void UARTSetup(uint32_t baudrate) {
  // UART settings:
  // * 8 data bits
  // * No parity bits (default)
  // * 1 stop bit (default)
  // * Asynchronous Normal mode (default)

  uint32_t const baseClockFrequency = F_CPU;
  uint32_t const uartClockDivider = 16;
  uint16_t const UBRRValue = (uint16_t)(
      (baseClockFrequency / (uartClockDivider * baudrate)) - 1);

  // Setup TX0 pin as output (PE1)
  DDRE |= _BV(PE1);

  // Set baudrate
  UBRR0 = UBRRValue;
  // Enable transmitter
  UCSR0B |= _BV(TXEN0);

}

int uart_putchar( char c, FILE *stream )
{
    if( c == '\n' )
        uart_putchar( '\r', stream );

    while (!(UCSR0A & _BV(UDRE0)))
    ;
    UDR0 = c;
    return 0;
}

void ICTimerInit() {

  TCCR4B |= _BV(ICES4) | _BV(CS40);
  // Enable input capture and overflow interrupts
  TIMSK4 |= _BV(ICIE4) | _BV(TOIE4);
}

// Input-capture event
ISR(TIMER4_CAPT_vect) {
  // Send the value over UART
  Tdiff = ICR4;
}

// Overflow event
ISR(TIMER4_OVF_vect) {
  // Add the max value of ICR register
  // to indicate that overflow happened
  // timeBetweenCaptures += 0xFFFF;
}

int main() {
  cli();
  UARTSetup(UART_BAUD_RATE);
  ICTimerInit();
  sei();  // enable interrupts

  while (1)
  {
    cli();
    val = Tdiff;
    sei();
    if (val){
    stdout = &mystdout;
    printf("%u\n",val);

    }

  }

}

OX is the number of samples, OY is the difference from two consecutive ICR4 values:

When it will be work in C, i will try modify this to c++.What argument do I need as a stream in this methood? Can you show me example of that ?

Welcome again. Due to problems at the university, I was able to take measurements only today. With code below i could meansure almost properly perioid from FM modulated signal ( for normally TTL signals i had almost good results)I tested this code on two arduino Mega2560 ( one clone, one original), and at original arduino this code wont work, received only one value regardless of the signal given. On clone program work very well, but sometimes i get this output ( pic). What is wrong with this code/ arduino ? Please help

#include <avr/interrupt.h>
#include <avr/io.h>
#include <util/delay.h>

#include <stddef.h>
#include <stdint.h>
#include <string.h>

#define _NOP()                   \
  do {                           \
    __asm__ __volatile__("nop"); \
  } while (0)

static constexpr uint32_t UART_BAUD_RATE{1000000};

/// LED-related functions ///

void LEDSetup() {
  // Set PB7 to output
  DDRB |= _BV(DDB7);
}

void LEDSetState(bool state) {
  if (state) {
    // Set PB7 to HIGH
    PORTB |= _BV(PB7);
  } else {
    // Set PB7 to LOW
    PORTB &= ~(_BV(PB7));
  }
}

void LEDToggle() {
  // Check PB7 state
  if (PINB & _BV(PB7)) {
    LEDSetState(false);
  } else {
    LEDSetState(true);
  }
}

/// UART-related functions ///

void UARTSetup(uint32_t baudrate) {
  // UART settings:
  // * 8 data bits
  // * No parity bits (default)
  // * 1 stop bit (default)
  // * Asynchronous Normal mode (default)

  uint32_t const baseClockFrequency = F_CPU;
  uint32_t const uartClockDivider = 16;
  uint16_t const UBRRValue = static_cast<uint16_t>(
      (baseClockFrequency / (uartClockDivider * baudrate)) - 1);

  // Setup TX0 pin as output (PE1)
  DDRE |= _BV(PE1);

  // Set baudrate
  UBRR0 = UBRRValue;
  // Enable transmitter
  UCSR0B |= _BV(TXEN0);
  // Set 8-bit frame format
  UCSR0C |= _BV(UCSZ01) | _BV(UCSZ00);
}

void UARTSendByte(uint8_t value) {
  // Wait until the previous transmission has ended
  while (!(UCSR0A & _BV(UDRE0)))
    ;
  // Put the data into buffer
  UDR0 = value;
}

void UARTSendBytes(uint8_t const* data, size_t length) {
  for (uint8_t const* ptr = data; ptr != (data + length); ptr++) {
    UARTSendByte(*ptr);
  }
}

void UARTSendString(char const* string) {
  UARTSendBytes(reinterpret_cast<uint8_t const*>(string), strlen(string));
}

template <typename T>
void UARTSendValue(T value) {
  UARTSendBytes((uint8_t const*)&value, sizeof(value));
}

/// Timer-related functions ///

void ICTimerInit() {
  // Use Timer4, because only ICP4 and ICP5 are accessible on Arduino Mega

  // Set capture on rising edge, and prescaler to 1 (timer should be clocked at
  // F_CLK)
  TCCR4B |= _BV(ICES4) | _BV(CS40);
  // Enable input capture and overflow interrupts
  TIMSK4 |= _BV(ICIE4) | _BV(TOIE4);
}

/// General functions ///

void resetSystemTimerPrescaler() {
  // Make sure that there's no prescaler on Fclk
  // To change prescaler, set CLKPCE bit in CLKPR register to 1,
  // while simultanously setting the prescaler bits - here, we
  // set them to 0 because we don't want any prescaler
  CLKPR = _BV(CLKPCE);
  // Wait 4 cycles to make sure the change is applied before proceeding
  _NOP();
  _NOP();
  _NOP();
  _NOP();
}

// Input-capture event
ISR(TIMER4_CAPT_vect) {
  // Send the value over UART
  UARTSendValue(static_cast<uint16_t>(ICR4));
}

// Overflow event
ISR(TIMER4_OVF_vect) {

}

int main() {
  cli();  // disable interrupts

  resetSystemTimerPrescaler();
  LEDSetup();
  UARTSetup(UART_BAUD_RATE);
  ICTimerInit();

  sei();  // enable interrupts

  while (true)
    ;
}

You are right, i overcomplicated code a little. Did you see any more places where this code could be crash ?

Thank you for your code. I will test this tomorrow.

why are you using the IRQ to do a send? Bad idea. IRQ should be fast in and out

I know that... Previously, I used a volatile variable to store ICR4 values and then send via USART when someting was in volatile variable ( if statment ) , but i was getting duplicate values ​​from the timer. I know it sounds funny, but it was.

so now you can more easily look at the actual code, to look for troubles. 

Based on previous observations, either the sending via USART is broken (which I doubt since it is very simple code) or the timer interrupts (the moment the sending and the timer interrupt capture new state from ICP). This is this a good starting point for analysis? This code is truly simple, toggle diode, capture state from ICP and send timer ICR value via USART, but give me a lot trouble.

Could you clarify that please?

 I try meansure time from signal like that: https://thottingal.in/blog/2014/...