SBUS implementation?

[grandaspanna]

A question in two parts:

1. has anyone seen a compatible SBUS implementation for this core?
2. If not, anybody got pointers for migrating a 328P implementation that is written around the hardware serial and Timer2? See: https://github.com/BrushlessPower/SBUS2-Telemetry

[SpenceKonde]

Oh dear lord......

Yeah that's gonna be fun to port.

I see no fundamental barriers, but just a bunch of tedious porting of "configure this peripheral to do this on a '328p" to "configure the corresponding peripheral on a modern AVR to do the same thing,

And don't do that godawful stuff with ISR function pointers. Never have ISRs call function pointers. That s a very bad design pattern that WInterrupt started. Just because the Arduino team did something apocalyptically bad becaise it was the only way to make the API they wanted happen, instead of making the API more consistent with what the hardware pushes you to do, doesn't mean we should do the same damned thing even when we don;t need to.
The right way to handle that is to toggle a global flag variable to set if it's in RX or TX mode - (is this finally a use case that actually justifies a use of a GPIOR bit in a practical program? I think it is!)

[SpenceKonde]

You'd be using a TCB on the modern AVR instead of the Timer2.

[HolleL]

Hello grandaspanna

I think, the Series 0/1/2 are great for SBUS, there have the option to inverted Pins (PORT_INVEN ) for the inverted SBUS-Signal, for need no Serial Bitbanging with Timer or a transistor, and can use the harware-serial :-)

I have tested a little with SBUS (old version with no Telemtry), no perfect, no failsave etc., but for first steps, its run:
https://www.rc-network.de/threads/sbus-switch.696022/post-12001653

greats Holle

[hmeijdam]

I have tested your sketch, but for me it does not work on a Attiny 1626.
In the serial1 monitor the servo pulse stays on 1000 and also on the pins 0 - 5

I also tried if the error was the declaration of the variables

uint8_t count,timeout,INBYTE[30];

I changed that to:

volatile uint8_t count,timeout,INBYTE[30];

as both 'count' and 'timeout' are used in the ISR, but that did not make any difference.

(tested with Jumper R8 and FRSky S8R receivers SBUS port)
What am I missing?

[HolleL]

I have tested with Graupner mx16 and Gr16
20MHZ with Attiny1624
The 1626 have the RX0 in PB3 too... ?!?

Run the ISR ? (check with an small Serial.print("x");

the timout 4 can be to high/low?
if(timeout>4){ count=0;
This count für see a new Datablock. Bettter use later millis/micros for this ?

[hmeijdam]

the 1626 has the RX0 also on PB3.
I did change the attach of servo 5 from pin 6 to pin 4, as on the 1626 the servo_5 at pin 6 would clash with the RX0, as both are on PB3

I put a led in the ISR, and I don't think the ISR is triggering. The led does not go on. Let me do some more debugging first.

[hmeijdam]

All sorted now and works just fine.
My test Jumper R8 receiver did not output a proper SBUS signal and when I tested with the S8R receiver I still had the servo_5 at pin 6, so that clashed the RX0. Another reason to stay far away from the Jumper gear

So the only modification needed for the 1626 is changing the servo_5 pin from 6 to 4. The volatile declaration was not needed, though I do not understand how it can work without, I led to belief that a variable should not be accessible in different functions, unless it's declared volatile. Your sketch shows different

[HolleL]

That great to hear :-)
Next step is make a better timeout (RTC-Timer or millis ?)

[HolleL]

I search a way to reset the RTC to zero (in the ISR), have anyone a idea ?

Or another idea ? (When there is on the Sbus Rx-ISR ~4mS no trigger, the count must be reset to zero. )

[CODE]
#include <Servo_megaTinyCore.h>
Servo SERVO_1;Servo SERVO_2;Servo SERVO_3;Servo SERVO_4;Servo SERVO_5;

volatile uint8_t count,timeout,INBYTE[30];
uint16_t Ch[16];

void setup() { Serial1.begin(115200); // Serialdebug nur beim Attiny 1624/3224 (mind. 2xUSART)
PORTB.PIN3CTRL |= PORT_INVEN_bm; // Rx Eingangsignale invertieren
USART0.BAUD =800; // 100.000bps SBUS für 20MHz
USART0.CTRLA |= USART_RXCIE_bm; // RX ISR ON
USART0.CTRLB |= USART_RXEN_bm; // RX aktivieren
SERVO_1.attach(0);SERVO_2.attach(1);SERVO_3.attach(2);SERVO_4.attach(3);SERVO_5.attach(6);

// RTC as peridic interrupt timer, all ~4mS
RTC.PITINTCTRL = RTC_PI_bm; // RTC Interrupt enable
RTC.PITCTRLA = RTC_PITEN_bm | RTC_PERIOD_CYC128_gc ; //RTC Prescaler on and Cycle-xxxx
}

void loop() {

for (uint8_t BBit=0, CBit=0, i=0; i<176; i++, BBit++, CBit++) {
  if(INBYTE[i/8+1] & _BV(BBit)) Ch[i/11+1] |= _BV(CBit); else Ch[i/11+1] &= ~_BV(CBit);
  if(BBit > 6) BBit=255;
  if(CBit > 9) CBit=255;
}

SERVO_1.writeMicroseconds((Ch[1]>>1)+1000);
SERVO_2.writeMicroseconds((Ch[2]>>1)+1000);
SERVO_3.writeMicroseconds((Ch[3]>>1)+1000);
SERVO_4.writeMicroseconds((Ch[4]>>1)+1000);
SERVO_5.writeMicroseconds((Ch[5]>>1)+1000);

Serialdebug(); delay(300); //only with Chips witz 2xUART

}

//Nur beim Attiny 1624/3224 (mind. 2xUSART)
void Serialdebug(){ //nur At1624
for (uint8_t i=1; i<5; i++) {
Serial1.print((Ch[i]>>1)+1000);
Serial1.print("\t");}
Serial1.println();
}

ISR(USART0_RXC_vect){
INBYTE[count] = USART0.RXDATAL;
count++;
// RESET RTC TIMER to zero !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
}

ISR(RTC_PIT_vect){ // RTC Interrupt
RTC.PITINTFLAGS = RTC_PI_bm; // clear Interrupt Flag
count = 0;
}
[/CODE]

[hmeijdam]

I don't think there is a 8 pin part in the 2 series. So serialdebug is never going to happen there.
I have a preference for the #define to select debugging options. That way I know for sure that without the debugging feature activated I have no overhead variables or code in my sketch, as it is all skipped during compilation.

looks to me like your serial debug is using the wrong USART0

[HolleL]

My last code run on the series1 At412 with serialdebug and servos. (Usart0 for SBUS and debug)

Or you mean, better use USART1 for Serialdebug for more safety only by Series 2, and Series 0/1 without debuging ?

The we can make it with (??)
#if defined USART1 //only when USART1 aviable
xxxxxxxxxxxxx
#endif

[hmeijdam]

Interesting. I did not realize you were using the same USART0 for both the SBUS inverted input and the Serial uninverted debug output. That is a clever idea. If that works fine, I would not even bother about using the second usart at all, but keep it transparent for all Attiny parts.

[HolleL]

Now with define for Serialdebug
Tested with Attiny 412 and 1624 with 16 and 20MHz

Serialdebug is 500000 bps

Only by the 8Pin Tinys:
When Serialdebug is activate, D0 is Serialdebug
When Serialdebug is not activate, D0 is Servo-1

// # define SERIALDEBUG                   //active for Serialdebug, but dont fly/drive with ist !! 

# define BAUD_SBUS   ((float)(F_CPU * 64 / (16 *(float)100000)) + 0.5)
# define BAUD_500000 ((float)(F_CPU * 64 / (16 *(float)500000)) + 0.5)

#include <Servo_megaTinyCore.h>
Servo SERVO_1; Servo SERVO_2; Servo SERVO_3; Servo SERVO_4; Servo SERVO_5;Servo SERVO_6;Servo SERVO_7;Servo SERVO_8;

volatile uint8_t count, Debugcount, timeout, INBYTE[30];
uint16_t Ch[16];

void setup() {

#if defined(__AVR_ATtinyxy2__)      // 8 pin parts
  PORTA.PIN7CTRL |= PORT_INVEN_bm;  // SBUS read in INVERT
  
  #if defined SERIALDEBUG   
    PORTA.DIR |= PIN6_bm;           // TX-Pin is OUTPUT
    USART0.CTRLB |= USART_TXEN_bm;  // USART0 TX ON
  #elif !defined SERIALDEBUG // Serialdebug and Servo share the Pin D0, never use both together
    SERVO_1.attach(0);
  #endif
    SERVO_2.attach(2); 
    SERVO_3.attach(3); 
    SERVO_4.attach(4);
//                          __  __
//                   VCC  -|o \/  |- GND                
// Serial/Servo-1 D0(PA6) -|tx    |- (PA3)D4 Servo-4
//           SBUS D1(PA7) -|rx    |- (PA0)D5 UPDI 
//        Servo-2 D2(PA1) -|______|- (PA2)D3 Servo-3
   

#elif defined(__AVR_ATtinyxy4__)    // 14 pin parts
  PORTB.PIN3CTRL |= PORT_INVEN_bm;  // SBUS read in INVERT
  USART0.CTRLB |= USART_TXEN_bm;    // USART0 TX ON
  PORTB.DIR |= PIN2_bm;             // TX-Pin is OUTPUT
  SERVO_1.attach(0); 
  SERVO_2.attach(1); 
  SERVO_3.attach(2); 
  SERVO_4.attach(3);
  SERVO_5.attach(6); 
  SERVO_6.attach(7); 
  SERVO_7.attach(9); 
  SERVO_8.attach(10); 
//                    __  __
//        -    VCC  -|o \/  |- GND                
//  Servo-1 D0(PA4) -|      |- (PA3)D10 Servo-8 
//  Servo-2 D1(PA5) -|      |- (PA2)D9  Servo-7 
//  Servo-3 D2(PA6) -|      |- (PA1)D8  (Tx1/Series2)
//  Servo-4 D3(PA7) -|      |- (PA0)D11 UPDI      
//    SBUS  D4(PB3) -|rx    |- (PB0)D7  Servo-6
//   Serial D5(PB2) -|tx____|- (PB1)D6  Servo-5

  
#elif defined(__AVR_ATtinyxy6__)   // 20 pin parts! 
  PORTB.PIN3CTRL |= PORT_INVEN_bm; // SBUS read in INVERT
  USART0.CTRLB |= USART_TXEN_bm;   // USART0 TX ON
  PORTB.DIR |= PIN2_bm;            // TX-Pin is OUTPUT
  SERVO_1.attach(0); 
  SERVO_2.attach(1); 
  SERVO_3.attach(2); 
  SERVO_4.attach(3);
  SERVO_5.attach(4); 
//                    __  __
//        -    VCC  -|o \/  |- GND                
//  Servo-x D0(PA4) -|      |- (PA3)D16 Servo-x
//  Servo-x D1(PA5) -|      |- (PA2)D15 Servo-x 
//  Servo-x D2(PA6) -|      |- (PA1)D14 Servo-x
//  Servo-x D3(PA7) -|      |- (PA0)D17 UPDI      
//  Servo-x D4(PB5) -|      |- (PB0)D13 Servo-x
//  Servo-x D5(PB4) -|      |- (PB1)D12 Servo-x
//     SBUS D6(PB3) -|rx    |- (PB1)D11 Servo-x
//   SERIAL D7(PB2) -|tx    |- (PB1)D10 Servo-x
//  Servo-x D8(PB1) -|______|- (PB1)D9  Servo-x
#endif

  USART0.BAUD = BAUD_SBUS;
  USART0.CTRLA |= USART_RXCIE_bm; // RX ISR ON
  USART0.CTRLB |= USART_RXEN_bm;  // RX ON



  // RTC as counter with OVF at ~4mS
  while (RTC_STATUS & RTC_PERBUSY_bm) {} // wait until RTC_PER is available for writing
  RTC_PER = 128; // Set TOP of timer to approximately 4 ms
  RTC_CLKSEL = RTC_CLKSEL_INT32K_gc; /* Internal 32kHz OSC */
  RTC_INTCTRL |= RTC_OVF_bm; // activate overflow interrupts
  RTC_CTRLA |= RTC_RTCEN_bm; // turn on RTC
}

void loop() {
  if (timeout) {
    timeout = 0;
    count = 0;
    for (uint8_t BBit = 0, CBit = 0, i = 0; i < 176; i++, BBit++, CBit++) {
      if (INBYTE[i / 8 + 1] & _BV(BBit)) Ch[i / 11 ] |= _BV(CBit); else Ch[i / 11] &= ~_BV(CBit);
      if (BBit > 6) BBit = 255;
      if (CBit > 9) CBit = 255;
    }
    #if defined SERIALDEBUG
     Serialdebug();
    #endif
 // if (SERIALDEBUG==1){ Serialdebug(); }  //do not fly with this !! 
  }
  SERVO_1.writeMicroseconds((Ch[0] >> 1) + 1000);
  SERVO_2.writeMicroseconds((Ch[1] >> 1) + 1000);
  SERVO_3.writeMicroseconds((Ch[2] >> 1) + 1000);
  SERVO_4.writeMicroseconds((Ch[3] >> 1) + 1000);
  SERVO_5.writeMicroseconds((Ch[4] >> 1) + 1000);
  SERVO_6.writeMicroseconds((Ch[5] >> 1) + 1000);
  SERVO_7.writeMicroseconds((Ch[6] >> 1) + 1000);
  SERVO_8.writeMicroseconds((Ch[7] >> 1) + 1000);
}



ISR(RTC_CNT_vect) { // RTC Interrupt
  RTC_INTFLAGS = RTC_OVF_bm; // clear Interrupt Flag
  timeout = 1;
}

ISR(USART0_RXC_vect) {
  INBYTE[count] = USART0.RXDATAL;
  count++;
  while (RTC_STATUS & RTC_CNTBUSY_bm) {} // wait until RTC_CNT is available for writing
  RTC_CNT = 0; // clear the RTC counter register
}

void Serialdebug() {
  USART0.BAUD= BAUD_500000;    //switch to faster Baudrate, that can read by the most Serialmonitors
  Debugcount++;   if (Debugcount >15) { Debugcount=0; SENDTXT("\n"); }  //send only one channel / round
  SENDVAL((Ch[Debugcount] >> 1) + 1000); 
  SENDTXT("\t");  
  delayMicroseconds(100); //wait short for buffer (better option ???) 
  USART0.BAUD= BAUD_SBUS;  //switch back to 100000bps SBUS
}

void SENDTXT(char *str) {
  for(uint8_t i = 0; i < strlen(str); i++) {
    while (!(USART0.STATUS & USART_DREIF_bm)){;} 
    USART0.TXDATAL = str[i];
} }
  
void SENDVAL(uint16_t Val) {
  char s[7]; SENDTXT(itoa( Val, s, 10 ));
}

[hmeijdam]

For replacing the
delayMicroseconds(100); //wait short for buffer (better option ???)
with a better option, it may be possible to use the TXCIF intterrupt flag in the USART0_STATUS register.

Bit 6 – TXCIF USART Transmit Complete Interrupt Flag
This flag is set when the entire frame in the Transmit Shift register has been shifted out, and there are no new data in
the transmit buffer (TXDATAL and TXDATAH) registers. It is cleared by writing a ‘1’ to it.

replace this

  SENDTXT("\t");  
  delayMicroseconds(100); //wait short for buffer (better option ???) 
  USART0.BAUD= BAUD_SBUS;  //switch back to 100000bps SBUS

by this

  SENDTXT("\t");  
  while (!(USART0.STATUS & USART_TXCIF_bm)){;}  // wait until TXCIF bit is set (buffer has been shifted out)
  USART0.STATUS |= USART_TXCIF_bm; // write "1" to TXCIF bit to clear it  
  USART0.BAUD= BAUD_SBUS;  //switch back to 100000bps SBUS

[SpenceKonde]

shouldn't 24 pin attiny 2-series parts get the same treatment?

…

On Sat, Aug 7, 2021 at 9:05 AM hmeijdam ***@***.***> wrote: Updated version that will automatically detect during compilation if it is a 14 or 20 pin part and if there is a second UART on board. #include <Servo_megaTinyCore.h> Servo SERVO_1; Servo SERVO_2; Servo SERVO_3; Servo SERVO_4; Servo SERVO_5; volatile uint8_t count, timeout, INBYTE[30]; uint16_t Ch[16]; void setup() { #if defined (__AVR_ATtinyx24__) || defined (__AVR_ATtinyx26__) // 2 series parts with 14 or 20 pins Serial1.begin(115200); // Serialdebug nur beim Attiny 1624/3224 (mind. 2xUSART) #endif PORTB.PIN3CTRL |= PORT_INVEN_bm; // Rx Eingangsignale invertieren USART0.BAUD = 800; // 100.000bps SBUS für 20MHz USART0.CTRLA |= USART_RXCIE_bm; // RX ISR ON USART0.CTRLB |= USART_RXEN_bm; // RX aktivieren SERVO_1.attach(0); SERVO_2.attach(1); SERVO_3.attach(2); SERVO_4.attach(3); #if defined(__AVR_ATtinyxy4__) // 14 pin parts SERVO_5.attach(6); #elif defined(__AVR_ATtinyxy6__) // 20 pin parts SERVO_5.attach(4); #endif // RTC as counter with OVF at ~4mS while (RTC_STATUS & RTC_PERBUSY_bm) {} // wait until RTC_PER is available for writing RTC_PER = 128; // Set TOP of timer to approximately 4 ms RTC_CLKSEL = RTC_CLKSEL_INT32K_gc; /* Internal 32kHz OSC */ RTC_INTCTRL |= RTC_OVF_bm; // activate overflow interrupts RTC_CTRLA |= RTC_RTCEN_bm; // turn on RTC } void loop() { if (timeout) { timeout = 0; count = 0; for (uint8_t BBit = 0, CBit = 0, i = 0; i < 176; i++, BBit++, CBit++) { if (INBYTE[i / 8 + 1] & _BV(BBit)) Ch[i / 11 ] |= _BV(CBit); else Ch[i / 11] &= ~_BV(CBit); if (BBit > 6) BBit = 255; if (CBit > 9) CBit = 255; } Serialdebug(); //only with Chips witz 2xUART } SERVO_1.writeMicroseconds((Ch[1] >> 1) + 1000); SERVO_2.writeMicroseconds((Ch[2] >> 1) + 1000); SERVO_3.writeMicroseconds((Ch[3] >> 1) + 1000); SERVO_4.writeMicroseconds((Ch[4] >> 1) + 1000); SERVO_5.writeMicroseconds((Ch[5] >> 1) + 1000); } //Nur beim Attiny 1624/3224 (mind. 2xUSART) void Serialdebug() { //nur At1624 #if defined (__AVR_ATtinyx24__) || defined (__AVR_ATtinyx26__) for (uint8_t i = 0; i <= 15; i++) { Serial1.print((Ch[i] >> 1) + 1000); Serial1.print("\t"); } Serial1.println(); #endif } ISR(USART0_RXC_vect) { INBYTE[count] = USART0.RXDATAL; count++; while (RTC_STATUS & RTC_CNTBUSY_bm) {} // wait until RTC_CNT is available for writing RTC_CNT = 0; // clear the RTC counter register } ISR(RTC_CNT_vect) { // RTC Interrupt RTC_INTFLAGS = RTC_OVF_bm; // clear Interrupt Flag timeout = 1; } — You are receiving this because you commented. Reply to this email directly, view it on GitHub <#499 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ABTXEW56L675H6WLE6BA7TLT3UVS5ANCNFSM5BQEJVJQ> . Triage notifications on the go with GitHub Mobile for iOS <https://apps.apple.com/app/apple-store/id1477376905?ct=notification-email&mt=8&pt=524675> or Android <https://play.google.com/store/apps/details?id=com.github.android&utm_campaign=notification-email> .

--

____________ Spence Konde Azzy’S Electronics New products! Check them out at tindie.com/stores/DrAzzy GitHub: github.com/SpenceKonde ATTinyCore <https://github.com/SpenceKonde/ATTinyCore>: Arduino support for all pre-2016 tinyAVR with >2k flash! megaTinyCore <https://github.com/SpenceKonde/megaTinyCore>: Arduino support for all post-2016 tinyAVR parts! DxCore <https://github.com/SpenceKonde/DxCore>: Arduino support for the AVR Dx-series parts, the latest and greatest from Microchip! Contact: ***@***.***

[hmeijdam]

Assuming your response is to my adapted code, They could get the same treatment but I left out the 24 pin parts as I don't use them and could not test my code. They are so small I need to solder them with my hotair solder gun, which is the reason I avoid them if I can.
Is there a way to get rid of the floats in the baudrate? They usually eat up a lot of resources