Hellschreiber is an On/Off keying mode which 'prints' out the characters as pixels. It is simple to use and easily decoded by eye though for tracking does require manual inputing of the data. In the case of the RFM22b it is necessary to setup an unmodulated carrier and then turn the transmitter on and off as required.

• Control is via SPI

//***************Hellschreiber******************
 
struct t_htab { char c; int hellpat[5]; } ;
 
struct t_htab helltab[] = {
 
  {'1', { B00000100, B00000100, B01111100, B00000000, B00000000 } },
  {'2', { B01001000, B01100100, B01010100, B01001100, B01000000 } },
  {'3', { B01000100, B01000100, B01010100, B01010100, B00111100 } },
  {'4', { B00011100, B00010000, B00010000, B01111100, B00010000 } },
  {'5', { B01000000, B01011100, B01010100, B01010100, B00110100 } },
  {'6', { B00111100, B01010010, B01001010, B01001000, B00110000 } },
  {'7', { B01000100, B00100100, B00010100, B00001100, B00000100 } },
  {'8', { B00111100, B01001010, B01001010, B01001010, B00111100 } },
  {'9', { B00001100, B01001010, B01001010, B00101010, B00111100 } },
  {'0', { B00111000, B01100100, B01010100, B01001100, B00111000 } },
  {'A', { B01111000, B00101100, B00100100, B00101100, B01111000 } },
  {'B', { B01000100, B01111100, B01010100, B01010100, B00101000 } },
  {'C', { B00111000, B01101100, B01000100, B01000100, B00101000 } },
  {'D', { B01000100, B01111100, B01000100, B01000100, B00111000 } },
  {'E', { B01111100, B01010100, B01010100, B01000100, B01000100 } },
  {'F', { B01111100, B00010100, B00010100, B00000100, B00000100 } },
  {'G', { B00111000, B01101100, B01000100, B01010100, B00110100 } },
  {'H', { B01111100, B00010000, B00010000, B00010000, B01111100 } },
  {'I', { B00000000, B01000100, B01111100, B01000100, B00000000 } },
  {'J', { B01100000, B01000000, B01000000, B01000000, B01111100 } },
  {'K', { B01111100, B00010000, B00111000, B00101000, B01000100 } },
  {'L', { B01111100, B01000000, B01000000, B01000000, B01000000 } },
  {'M', { B01111100, B00001000, B00010000, B00001000, B01111100 } },
  {'N', { B01111100, B00000100, B00001000, B00010000, B01111100 } },
  {'O', { B00111000, B01000100, B01000100, B01000100, B00111000 } },
  {'P', { B01000100, B01111100, B01010100, B00010100, B00011000 } },
  {'Q', { B00111000, B01000100, B01100100, B11000100, B10111000 } },
  {'R', { B01111100, B00010100, B00010100, B00110100, B01011000 } },
  {'S', { B01011000, B01010100, B01010100, B01010100, B00100100 } },
  {'T', { B00000100, B00000100, B01111100, B00000100, B00000100 } },
  {'U', { B01111100, B01000000, B01000000, B01000000, B01111100 } },
  {'V', { B01111100, B00100000, B00010000, B00001000, B00000100 } },
  {'W', { B01111100, B01100000, B01111100, B01000000, B01111100 } },
  {'X', { B01000100, B00101000, B00010000, B00101000, B01000100 } },
  {'Y', { B00000100, B00001000, B01110000, B00001000, B00000100 } },
  {'Z', { B01000100, B01100100, B01010100, B01001100, B01100100 } },
  {'.', { B01000000, B01000000, B00000000, B00000000, B00000000 } },
  {',', { B10000000, B10100000, B01100000, B00000000, B00000000 } },
  {'/', { B01000000, B00100000, B00010000, B00001000, B00000100 } },
  {'*', { B00000000, B00000000, B00000100, B00001110, B00000100 } }
 
};
 
#define N_HELL  (sizeof(helltab)/sizeof(helltab[0]))
 
void helldelay()
{
  //Slow Hell
  delay(64);
  delayMicroseconds(900);
 
  //Feld-Hell
  //delay(8);
  //delayMicroseconds(160);
 
}
 
void on()
{
  radio1.write(0x07, 0x08); //on
  helldelay();
  radio1.write(0x07, 0x01); //off
}
 
void hellsend(char c)
{
  int i ;
  if (c == ' ') {
      for (int d=0; d<14; d++){
        helldelay();  
      }
    return ;
  }
  for (i=0; i<N_HELL; i++) {
    if (helltab[i].c == c) {
      //Serial.print(helltab[i].c) ;
 
      for (j=0; j<=4; j++) 
      {
        byte mask = B10000000;
        for (q=0; q<=6; q++)
        {      
          if(helltab[i].hellpat[j] & mask) {
            on();
          } else {
            helldelay();
          }
          mask >>= 1;
        }
      }
      for (int d=0; d<14; d++){
        helldelay();  
      }
      return ;
    }
  }
  /* if we drop off the end, then we send a space */
  //Serial.print("?") ;
}
 
void hellsendmsg(char *str)
{
  radio1.setFrequency(434.201);
  delay(1000);
  while (*str)
    hellsend(*str++) ;
  //Serial.println("");
}
 
void loop(){
   hellsendmsg(superbuffer);
   radio1.write(0x07, 0x01); // turn tx off
}

RTTY can be generated on the RFM22b by switching the frequency of the transmitter between MARK and SPACE. The radio is setup to transmit and unmodulated carrier and then over SPI we just change the frequency via the library. Using this it is quite possible to transmit at 50baud with a 500Hz shift.

• All control is via SPI

//Taken from the RF22 Library (http://www.open.com.au/mikem/arduino/RF22/)
// Returns true if centre + (fhch * fhs) is within limits
// Caution, different versions of the RF22 suport different max freq
// so YMMV
boolean rfm22::setFrequency(float centre)
{
    uint8_t fbsel = 0x40;
    if (centre < 240.0 || centre > 960.0) // 930.0 for early silicon
		return false;
    if (centre >= 480.0)
    {
		centre /= 2;
		fbsel |= 0x20;
    }
    centre /= 10.0;
    float integerPart = floor(centre);
    float fractionalPart = centre - integerPart;
 
    uint8_t fb = (uint8_t)integerPart - 24; // Range 0 to 23
    fbsel |= fb;
    uint16_t fc = fractionalPart * 64000;
    write(0x73, 0);  // REVISIT
    write(0x74, 0);
    write(0x75, fbsel);
    write(0x76, fc >> 8);
    write(0x77, fc & 0xff);
}

// RTTY Functions - from RJHARRISON's AVR Code
void rtty_txstring (char * string)
{
 
	/* Simple function to sent a char at a time to 
	** rtty_txbyte function. 
	** NB Each char is one byte (8 Bits)
	*/
	char c;
	c = *string++;
	while ( c != '\0')
	{
		rtty_txbyte (c);
		c = *string++;
	}
}
 
void rtty_txbyte (char c)
{
	/* Simple function to sent each bit of a char to 
	** rtty_txbit function. 
	** NB The bits are sent Least Significant Bit first
	**
	** All chars should be preceded with a 0 and 
	** proceded with a 1. 0 = Start bit; 1 = Stop bit
	**
	** ASCII_BIT = 7 or 8 for ASCII-7 / ASCII-8
	*/
	int i;
	rtty_txbit (0); // Start bit
	// Send bits for for char LSB first	
	for (i=0;i<8;i++)
	{
		if (c & 1) rtty_txbit(1); 
			else rtty_txbit(0);	
		c = c >> 1;
	}
	rtty_txbit (1); // Stop bit
        rtty_txbit (1); // Stop bit
}
 
void rtty_txbit (int bit)
{
		if (bit)
		{
		  // high
                  radio1.setFrequency(434.2010);
		}
		else
		{
		  // low
                  radio1.setFrequency(434.2015);
		}
                delayMicroseconds(19500); // 10000 = 100 BAUD 20150
 
}
 
void loop(){
      radio1.write(0x07, 0x08); // turn tx on
      delay(5000);
      rtty_txstring("$$$$");
      rtty_txstring(superbuffer);
      radio1.write(0x07, 0x01); // turn tx off
}

On the RFM22b it is necessary to control the TX_ANT and RX_ANT pins. These pins control antenna diversity regarding the Rx state, its not clear in the datasheet what is really required however various user experience seems to suggest that while everything works when these pins are left floating its not the most efficient setup, instead by controlling the pins you can increase the transmission by up to 5db. This is probably the cause of the failure of PicoAtlas6 MK2 where the pins were wired up correctly but hadn't been set in the right mode.

• GPIO0 → TX_ANT
• GPIO1 → RX_ANT

//This sets up the GPIOs to automatically switch the antenna depending on Tx or Rx state, only needs to be done at start up
write(0x0b,0x12);
write(0x0c,0x15);

Info taken from the RF22 library (2)

• Not yet done (lost module on last flight )

1. http://arduino.cc/forum/index.php?topic=50533.15
2. http://www.open.com.au/mikem/arduino/RF22/