volatile didnt work either... =(

okay, atomic access is totally new to me. how do I do that? How can i 
shorten or modify my code so it doesn't corrupt the timing? my plan was 
to fill an array and transmit it when it's full.

okay, my idea would be to put the tx() inside an if(i==512)... into 
loop, so that cli/sei can be used (and transmission is not disturbed). 
but what about atomic access? Did you mean the functions of 
<util/atomic.h>?

cleaned version without atomic access:

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

volatile int val[512] = { 0 };
volatile int i = 0;

void setup() {
  Serial.begin(115200);
  cli();                                     // disable interrupts while 
messing with their settings
  TCCR1A = 0x00;                             // clear default timer 
settings, this kills the millis() funciton
  TCCR1B = 0x00;
  TCCR1B |= (1 << WGM12);                    // Configure timer 1 for 
CTC mode
  TCCR1B &= ~(0 << CS12);                    // Set timer prescaling by 
setting 3 bits
  TCCR1B |= (1 << CS11 | 1 << CS10);         // 001=1, 010=8, 011=64, 
101=1024
  TIMSK1 |= (1 << OCIE1B);                   // Enable CTC interrupt
  OCR1B  = 5000;                               // Set CTC compare value

  ADMUX = B01100000;                         // left adjusted output to 
increase sample rate, 8bit mode
  SMCR |= (1 << SM0);                        // Enable sleep AD 
conversion mode
  SMCR &= ~( (1 << SM2) | (1 << SM1) );
  //SREG |= (1 << ADIE);                       // Enable ADC ready 
interrupt
  ADCSRB |= ( ( 1 << ADTS2 | 1 << ADTS0 ) ); // configure ADC to trigger 
on Timer Compare Match B
  ADCSRB &= ~(1 << ADTS1);
  sei();                                     // turn interrupts back on
  ADCSRA = B11001111;                         // set ADC prescaler to 
128, ADC EN, ADC Start
}

void loop() {
if(i==512){
}
tx();
}

void tx(){
    cli();
    for (int q=0;q<512;q++){
    Serial.print(val[q]);
    Serial.print(",");
    }
    Serial.println();
    i = 0;
  sei();
}

void rx(){

}

ISR(ADC_vect)
{
  val[i] = (int)ADCH;
  i++;
}

sorry, I am still a bit a kind of noob, is this code better for doing 
the job? According to the link above it would be useful if I reduce the 
array size to 128 as well as the datatype to Byte to workaround using

ATOMIC_BLOCK(ATOMIC_FORCEON)
      {

      }

right?

Sorry, I meant an array size of 255 -> byte

Hi Falk,

richtig geraten =) hab den Artikel gelesen, aber so richtig verstanden 
hab ich ihn nicht:

 PINx = (PORTx & 0x0F) ^ lcd_data;

ist laut Artikel die Sollvorgehensweise. Was bedeutet das in meinem 
Fall? ich meine Atomarer als val[i]=ADCH gehts ja nicht, oder soll ich 
da direkt mit Speicheradressen statt mit val[i] arbeiten? Atomar heißt 
ja nur, dass währenddessen nichts anderes ausgeführt werden kann oder?

Tobias K. wrote:

>  PINx = (PORTx & 0x0F) ^ lcd_data;
> ist laut Artikel die Sollvorgehensweise.

Das ist eine mögliche Vorgehensweise, aber nur bei Ports, nicht bei 
Speichervariablen. Bei denen ist eine dieser ATOMIC_BLOCK Klammern genau 
richtig. Und zwar bei jedem Zugriff ausserhalb der ISR.

Nicht atomar kann heissen:
  unteres Byte lesen (alt),
  Interrupt mischt mit und zählt hoch,
  oberes Byte lesen (neu).
Das gibt dann gelesenen Datensalat und ist nur durch temporäre 
Abschaltung des Interrupts zu vermeiden.

okay, cool. Das heißt

ISR(ADC_vect)
{
  val[i] = ADCH;
  i++;
}

passt soweit, nur in der Loop und (?) in tx() kommen die Klammern zum 
Einsatz? Habe die Variablen alle mal auf 8bit runtergeschraubt, was ja 
die Zwangsatomisierung erübrigen sollte, da kam aber auch nix bei rum...

Vielen Dank schonmal für euer feedback!

Hi Falk,

ich wollte absichtlich nur das High Register lesen, weil man dadurch die 
Sampling rate hoch bekommt. hab den ADC auch entsprechend left adjusted 
konfiguriert. Werde ich gleich mal probieren, Deine Variante =)

BTW: warum ist i als Name ungünstig?

mist, kann es sein dass ich auch das globale array in ein lokales 
kopieren muss? In der Form funktionierts noch nicht...

grrrr... der globale Counter wird immer noch nicht hochgezählt...

ich sende aus der ISR heraus gCnt

(anhang geht irgendwie nich... hier noch mal gepastet:)

/*
this goes on your arduino
for use with Processing example SimpleSerialArduinoscope
*/
#include <avr/io.h>
#include <avr/interrupt.h>
//#include <util/atomic.h>

volatile int val[255] = { 0 };
volatile byte gCnt = 0;

void setup() {
  Serial.begin(115200);
  cli();                                     // disable interrupts while 
messing with their settings
  TCCR1A = 0x00;                             // clear default timer 
settings, this kills the millis() funciton
  TCCR1B = 0x00;
  TCCR1B |= (1 << WGM12);                    // Configure timer 1 for 
CTC mode
  TCCR1B &= ~(0 << CS12);                    // Set timer prescaling by 
setting 3 bits
  TCCR1B |= (1 << CS11 | 1 << CS10);         // 001=1, 010=8, 011=64, 
101=1024
  TIMSK1 |= (1 << OCIE1B);                   // Enable CTC interrupt
  OCR1B  = 5000;                             // Set CTC compare value

  ADMUX = B01100000;                         // left adjusted output to 
increase sample rate, 8bit mode
  SMCR |= (1 << SM0);                        // Enable sleep AD 
conversion mode
  SMCR &= ~( (1 << SM2) | (1 << SM1) );
  //SREG |= (1 << ADIE);                     // Enable ADC ready 
interrupt
  ADCSRB |= ( ( 1 << ADTS2 | 1 << ADTS0 ) ); // configure ADC to trigger 
on Timer Compare Match B
  ADCSRB &= ~(1 << ADTS1);
  sei();                                     // turn interrupts back on
  ADCSRA = B11001111;                        // set ADC prescaler to 
128, ADC EN, ADC Start
}

void loop() {
        if(gCnt==255){
            tx();
        }
}

void tx(){
 byte tmp;
 int valTmp[255];
    cli();
    tmp = gCnt;
    for(byte i;i<255;i++){
    valTmp[i] = val[i];
    }
    gCnt=0;
    sei();

    for (byte q=0;q<255;q++){
    Serial.print(val[q]);
    Serial.print(",");
    }
    Serial.println();
}

void rx(){

}

ISR(ADC_vect)
{
  val[gCnt] = ADCW;
  Serial.print((int)gCnt);
  gCnt += 1;
}

Ja sorry, hab ich vergessen zu sagen: ich programmiere den Atmega mit 
der Arduinoplattform, da gibts meines Wissens kein main.

Okay, ich habe jetzt einfach Ockham's Razor geschwungen und es geht:

ISR(ADC_vect)
{
  Serial.println((int)ADCH);
}

Trotzdem vielen dank für den Exkurs in atomare Interrupt Behandlung =)