Attempting to take over TCD0 on a AT412. Why do I fail?

[hmeijdam]

Together with my new friends the datasheet and the header file I am attempting to take control of the timer D on a Attiny412

My sketch turns on TCD0, reads the 12 bit timer value and prints it, when higher than the last printed value. I expect it to reach the maximum 12 bit value of 4095.
I can only make it work partly when I compile it with the option millis()/micros() enabled on timer TCD0. It will then count to 509 because in wiring.c the TOP of the timer is lowered.
TCD0.CMPBCLR = TIME_TRACKING_TIMER_PERIOD; //essentially, this is TOP

Now when I compile with millis()/micros() disabled I capture the value 0. So I am forgetting something, but what ??

Please find below my small sketch:

// ATtiny412 / ARDUINO
//                                     _____
//                             VDD   1|*    |8  GND
//       (TXD) (DAC) (AIN6) PA6  0   2|     |7  4~  PA3 (AIN3)(SCK)(EXTCLK)
//       (RXD)       (AIN7) PA7  1   3|     |6  5   PA0 (nRESET/UPDI)
// (MOSI)(TXD*)(SDA) (AIN1) PA1  2   4|_____|5  3   PA2 (AIN2)(MISO)(RXD*)(SCL)
//
//

uint16_t capture = 0;
uint16_t maxcapture = 0;

void setup() {
  takeOverTCD0();// Understand this will give me control of the timer.

  //Serial.swap();// use this to set the TXD*/RXD* to their alternate pins
  Serial.begin(115200);// Default Serial TX is on pin 0 (PA6)

  // configure timer D
    TCD0.CTRLB |= TCD_WGMODE_ONERAMP_gc; // Set timer to one ramp mode (=default)
    TCD0.CTRLA |= TCD_CLKSEL_20MHZ_gc; // Internal 16/20 MHz Oscillator (OSC20M)
    TCD0.CTRLA |= TCD_CNTPRES_DIV32_gc; // Division factor  (1, 4 or 32 possible)
    TCD0.CTRLA |= TCD_SYNCPRES_DIV8_gc; // Division factor  (1, 2, 4 or 8 possible)
    TCD0.CTRLA |= TCD_ENABLE_bm; // enable TCD0

  Serial.println(TCD0.CTRLA, BIN); // to check content of CTRLA
  Serial.println(TCD0.STATUS, BIN);// to check content of STATUS
}

void loop() {
  //TCD0.STATUS |= TCD_PWMACTB_bm; // serial seems to use activity on B ??
  //delay(1);
  TCD0.CTRLE = TCD_SCAPTUREA_bm; //ask for a (TCDn.CAPTUREAL/H)
  while (!(TCD0.STATUS & TCD_CMDRDY_bm));//wait for sync (= capture done)
  capture = TCD0_CAPTUREA; // reading capturea high byte also unlocks it!
  //  capture = TCD0_CAPTUREAL; // read the low byte first because......
  //  capture = capture + (TCD0_CAPTUREAH << 8);//reading Capturea high byte unlocks it
  if (capture > maxcapture) {
    maxcapture = capture;
    Serial.println(maxcapture);
  }
}

note1) capturing the low byte / high byte separately or in one go did not make a difference
note2) I also tried my capture with capture = TCD0.CAPTUREA; (saw that in the core. It works the same, though is not green or red highlighted in the IDE).

[SpenceKonde]

What value do you see for TCD0.CMPBCLR? I don't see you writing that to set TOP anywhere. I think its reset value is 0x000, so it's overflowing every timer tick and never getting higher than 0.

If that's not it, print out the values of all the registers of TCD0, writing the results to Serial.

also - Serial.println(value,BIN)? you'll probably be happier with Serial.printHex() - prints most types directly as hexadecimal....without pulling in quite as much bloat as the normal print methods at some point I'm planning to release a microscopic serial librariy.

Also, this sort of construction is evil (mayber "evil" is too dramatic - "bad" may be more correct) - only do this when it's actually what you need the chip to do.

    TCD0.CTRLA |= TCD_CLKSEL_20MHZ_gc; // Internal 16/20 MHz Oscillator (OSC20M)
    TCD0.CTRLA |= TCD_CNTPRES_DIV32_gc; // Division factor  (1, 4 or 32 possible)
    TCD0.CTRLA |= TCD_SYNCPRES_DIV8_gc; // Division factor  (1, 2, 4 or 8 possible)
    TCD0.CTRLA |= TCD_ENABLE_bm; // enable TCD0

Don't do consecutive bit-writes to registers (which are volatile - the compiler can't optimize that into a single write) unless you require them to be separate writes. You know that TCD0.CTRLA = 0 to start with (or it godda ed well should be after calling the takeover function), So why not just do TCD0.CTRLA = TCD_CLKSEL_20MHZ_gc | TCD_CNTPRES_DIV32_gc | TCD_SYNCPRES_DIV8_gc | TCD_ENABLE_bm; ?

That is 3 words of flash and 3 clock cycles (ldi - load immediate - to load the 8-bit constant to a working register, and sts - store direct - to write it, the latter is a 2 word, 2 clock instruction.

What you have is would turn into something like lds (load direct, 2 words 3 clocks, load the existing value to working register), ori (or it with that bitfield - 1 word 1 clock) , sts (2 words 2 clocks) to store it **got eraj Hence 5 words (10 bytes) per line. And it can't combine them because the peripheral registers are volatile - it has to do a read-modify-write cycle for each one.

Overuse of |= on separate lines to write registers is a common idiom that I see in ArduinoLand - I think it comes from the classic AVR days... where common control registers for peripherals were in the low IO space, where that's not as painful. But the advice to use it gets told to people without enough information for them to know when it's valid, so it was used in cases where it was much worse than the alternatives. In the case of your example - if that were in the low I/O space, it would compile down to 4 words, 4 clocks. Still worse than simple assignment, but nowhere near the 20 words thaty the

There are 32 registers at most on a given AVR part for which |= can be super efficient: If the register being written to resides in the mythical Low I/O space - that is it is located at an address between 0 and 31, then sbi and cbi instructions can be used on it. These work ONLY on those registers, when the value being OR'ed has only a single bit set, or being AND'ed has all but one bit set., and is compile time known). On the classic AVRs, there was some variation and mystery to which registers were in the low I/O space on a given part. On modern ones, there's no mystery: 0x00 through 0x1B are the VPORT registers for the ports A through G, followed by the GPIOR0-GPIOIR3 (which are general purpose i/o space registers that you can use as you wish - GPIOR0 may be written by the bootloader and/or core during startup as documented - the bootloader uses it to pass the reset cause to the application, because it has to clear the reset flags so that it can honor the specified entry conditions and only those), but nothing after startup reads or writes them unless you write code to do that yourself). Those are the only registers that you can do magic interrupt safe bitsets/clears. There's also an corresponding test instruction (skip-if-bit-in-io-register-is-set/cleared, sbis/sbic - so if (VPORTA.IN & 1<<4 ) is also hyperefficient. Same constraints though - single bit, known at compile time - otherwise it gets a more typical and less efficient implementation.

I actually had tons of cide like that in ATTinyCore (the legacy core). Wehn I was looking over it last summer, having finally learned what not to do. at the drop of a hat i was anler to drop the size of init() on most parts by on ther order of a hundred bytes

[hmeijdam]

Thanks, that was it. I did not realize I have to set the TOP value myself in TCD0.CMPBCLR and was incorrectly assuming it would run to it's max by default. By adding TCD0.CMPBCLR = 4095; just before enabling the timer it now works as expected.

or...when I want to set TCD0.CMPBCLR after I have enabled the timer I have to add these 3 lines

  while (!(TCD0.STATUS & TCD_CMDRDY_bm));//wait for ready to receive a command in double buffer
  TCD0.CMPBCLR = 4095;
  TCD0.CTRLE |= TCD_SYNC_bm; // send synchronization command to load double buffer to TCD0

My "evil" constructions of setting a register via sequential read>modify>writes is because it helps me learning and documenting what I am doing. One by one I need to understand what the bits in the control registers do. Sometimes it's clear from the datasheet, but more often than not I have to try out different settings before I grasp the meaning. Then it's easier for me not to have to look them up in the datasheet over and over again, but document them in my source, to remember why it's there and what it's for.

Once the code is ready I compact all the register manipulations and delete the ones that don't change default values, change PORT to VPORT and observe how the compiler compacts the binary with every step.
be assured I have been reading all of the documentation you put up about efficient coding.
But even then I often leave the (then commented) "evil" constructions in my source, so that if I come back to it months later I can read and remember what I have done.
I learned the hard way that if I d not document carefully I will be lost when I look at my own code later. I have quite a few programs that if I look at them now, I have a very hard time understanding my own mechanism how I made it work when I wrote them.
And thanks again for your fast response. Much appreciated.

[hmeijdam]

I'm planning to release a microscopic serial librariy.

That is promising, as it will make debugging easier on the low memory parts, where I have to discard Serial as debugging option, when I need the memory space that it eats.

[SpenceKonde]

Think putch() and getch() if you're familiar with classic low level implementations of serial. You'll get I think 2 bytes buffer from the hardware USART implementation, beyond that, TX is blocking. Likewise for RX you get only the 2 bytes of hardware buffer without data loss. No interrupts. compile time known baud rates only. Chars, and char arrays will print as characters. Numeric types will be rendered as hex. No decimal output (do you not like that? Okay, then you try to implement that yourself. And you can't use division, it pulls in mad bloat). No floating point (if you're trying to save flash, and you';re using floats, that'd be the reason you have a flash problem)

[hmeijdam]

That should be just fine. I have used putchar() on the STM8S to print stuff to the terminal.

[hmeijdam]

As a quick and dirty solution, until your microscopic serial library will be finished, I created some boilerplate code that I can integrate in my sketches to print some debugging info. This should compile for all the Tinies in this core. Maybe others can benefit from this. Keep in mind that this example is for Attiny412 and the default TXD and alternate TXD* pins will be different on other parts. Since you have to set the TXD pin as output this pin will be different for other parts.

Version with Setup() and Loop() ( 396 bytes )

// example ATtiny412 pins
//                                     _____
//                             VDD   1|*    |8  GND
//       (TXD) (DAC) (AIN6) PA6  0   2|     |7  4~  PA3 (AIN3)(SCK)(EXTCLK)
//       (RXD)       (AIN7) PA7  1   3|     |6  5   PA0 (nRESET/UPDI)
// (MOSI)(TXD*)(SDA) (AIN1) PA1  2   4|_____|5  3   PA2 (AIN2)(MISO)(RXD*)(SCL)
//
//
// If using another part than Attiny412 you may need to define other pins for TXD and TXD* !

#include <util/delay.h>     
char printbuffer[7];         //the ASCII of the integer will be stored in this char array
const static uint8_t Sometext[] = " and counting !\r\n"; // A string array with some fixed text
int8_t a; // this value will be used 

//#define USE_ALTERNATE_TXD  //  uncomment if you want to use the alternate TXD* / RXD* pins

void setup() {
  USART_init(9600);    //Call the USART initialization code and choose your ( baudrate )
}

void loop() {
  a = a + 1; // increasing value that will be printed
  itoa(a, printbuffer, 10);    //(integer, yourBuffer, base)
  USART_putstring(printbuffer); // print the
  USART_putstring(Sometext);
  _delay_ms(200);          
}

void USART_init(uint16_t BAUDRATE) {
  USART0_BAUD = (F_CPU * 64 / (BAUDRATE * 16UL));
#ifdef USE_ALTERNATE_TXD
  PORTMUX_CTRLB = PORTMUX_USART0_bm; // activate alternate RXD* / TXD* pins
  VPORTA_DIR |= PIN1_bm;   // set pin PA1 as output (= alternate TXD* pin on Attiny412)
#else
  VPORTA_DIR |= PIN6_bm;   // set pin PA6 as output (= default TXD pin on Attiny412)
#endif
  USART0_CTRLB |= USART_TXEN_bm ; //enable tx only
}

void USART_send(unsigned char data) {
  while (!(USART0_STATUS & USART_DREIF_bm));
  USART0_TXDATAL = data;
}

void USART_putstring(char* StringPtr) {
  while (*StringPtr != 0x00) {
    USART_send(*StringPtr);
    StringPtr++;
  }
}

And a slightly smaller version with main() instead of setup & loop ( 332 bytes )

// example ATtiny412 pins
//                                     _____
//                             VDD   1|*    |8  GND
//       (TXD) (DAC) (AIN6) PA6  0   2|     |7  4~  PA3 (AIN3)(SCK)(EXTCLK)
//       (RXD)       (AIN7) PA7  1   3|     |6  5   PA0 (nRESET/UPDI)
// (MOSI)(TXD*)(SDA) (AIN1) PA1  2   4|_____|5  3   PA2 (AIN2)(MISO)(RXD*)(SCL)
//
//
// If using another part than Attiny412 you may need to define other pins for TXD and TXD* !

#include <util/delay.h> 
//#define USE_ALTERNATE_TXD  //  uncomment if you want to use the alternate TXD* / RXD* pins

int main(void) {
  // reconfigure CPU clock prescaler
  CCP = CCP_IOREG_gc;    // enable write to protected IO registers (timed sequence)
  CLKCTRL_MCLKCTRLB = 0; // turn off prescaler (and the default factor 6 division)
  USART_init(9600);      //Call the USART initialization code and choose ( baudrate )

  char printbuffer[7];   //The ASCII of the integer will be stored in this char array
  const static uint8_t Sometext[] = " and counting !\r\n"; // A string array with some fixed text

  while (1) {      //Infinite loop
    int8_t a = a + 1; // increasing value that will be printed
    itoa(a, printbuffer, 10);    //(integer, yourBuffer, base)
    USART_putstring(printbuffer); // print the 
    USART_putstring(Sometext);
    _delay_ms(200);          
  }
}

void USART_init(uint16_t BAUDRATE) {
  USART0_BAUD = (F_CPU * 64 / (BAUDRATE * 16UL));
#ifdef USE_ALTERNATE_TXD
  PORTMUX_CTRLB = PORTMUX_USART0_bm; // activate alternate RXD* / TXD* pins
  VPORTA_DIR |= PIN1_bm;   // set pin PA1 as output
#else
  VPORTA_DIR |= PIN6_bm;   // set pin PA6 as output
#endif
  USART0_CTRLB |= USART_TXEN_bm ; //enable tx only
}

void USART_send(unsigned char data) {
  while (!(USART0_STATUS & USART_DREIF_bm));
  USART0_TXDATAL = data;
}

void USART_putstring(char* StringPtr) {
  while (*StringPtr != 0x00) {
    USART_send(*StringPtr);
    StringPtr++;
  }
}