Satellite Transmitter, help me make it!

[kevin286]

I've got:
Axonn STX2 satellite transmitter
Home made Atmega8 Arduino
Freedruino (atmega168)
PCB etched
Most of the little stuff needed
Some basic experience
Lots of background with simplex satellite

I work at a small company that deals in GPS tracking via simplex satellite modems and as such have rescued quite a bit of junk before it's scrapped.
I've been working with the Arduino stuff for a little while now and have a basic understanding but I've never used the Arduino to 'talk' to anything before.

The STX2 uses rx, tx, cts, and rts at 3.3 ttl levels. I'm fairly certain the softwareSerial library can be used to make this all work and once done this would be a satellite modem capable of transmitting 8 bytes. I can arrange for the satellite applique to forward it in xml to any server address. Read: really cool stuff here. This is the same satellite transmitter the SPOT personal location beacon uses.

The problem is that I lack the knowledge to write the serial 'talking' code to make this all happen.

Help me make this and be part of a nifty project.
Here's pictures of the project so far http://www.flickr.com/photos/22353551@N05/sets/72157609275360606/
Tell me what you need; I've got data sheets, pinouts, etc.
-Kevin

[eil]

You've got my attention! :)

1) I was under the impression that in order to transmit to a satellite you needed some sort of high-powered thing mounted to a dish. Is this not the case with your project? I'm not familar with this "simplex" system. (Though the name sounds familiar, so I've probably heard of it before.)

2) What are the costs here? How much is a modem? How much is "airtime" on the satellite network?

3) What's the 8-byte limitation all about? Is that some kind of time-based quota or can you send as many 8-byte strings strings as you want?

4) Does the Arduino need to set up the communication channel at all, or does the modem handle all that?

[mzapatasilva]

Hi,
I am currently working on a proyect that comunicates using two serial ports on the Arduino, one using the UART and the other using the SotSerial.

PC-serial <---> ARDUINO <---> GPS or Compass using NMEA protocol

You could replace the PC with your modem (satelite)

PC stand for PErsonal Computer (is the client that asks data to Arduino for the GPS or Compass)


How I did it:
steps
1.- Design a protocol to upload to satelite.... my case 10 Bytes Bytes [start][command][index] [param][data1] [data2] [data3] [dat4] [cc][cc] where cc is for checksum, data1-4 is a long integer with sing, etc...
2.-Design a time flow .... my example
PC ARDUINO GPS/COMPASS ANALOG OUTPUTS
--------send command-->
<-----------------answer--
-------ask data----------->
< --data every second---
<-----------data procesed ----

3.- Draw a simple flow chart .....
4.- Implement one box form the chart at a time. I use several windows in Arduino IDE, one file per hardware o logic module.
5.- Test one box(function or set of functions) at a time
6.-Fix delays, memory issues...
7.- Test end to end...
8.-Publish

KR

[kevin286]

You've got my attention!

1) I was under the impression that in order to transmit to a satellite you needed some sort of high-powered thing mounted to a dish. Is this not the case with your project? I'm not familar with this "simplex" system. (Though the name sounds familiar, so I've probably heard of it before.)

2) What are the costs here? How much is a modem? How much is "airtime" on the satellite network?

3) What's the 8-byte limitation all about? Is that some kind of time-based quota or can you send as many 8-byte strings strings as you want?

4) Does the Arduino need to set up the communication channel at all, or does the modem handle all that?

You don't always need a high-power transmitter to transmit. This particular device operates on the side bands of the Globalstar voice system. I'm sure you've seen the Globalstar satellite phones with the fold out antennas? Picture and description of phone
The device I'm working with transmits at about -27dB, so very low power.

I'm not sure what the cost of the modem part is as its a piece salvaged off of existing hardware. I would take a guess at 50-100 dollars for the hardware. There is 'airtime' fees as well but this is not per minute but rather per message with a message being 8 bytes.

The 8 byte limitation is due to a variety of reasons but it is what I'm able to use for testing. While the unit should be able to transmit 32 bytes this is seldom used due to higher likely hood of error and higher costs. Remembering that this is a simplex system E.G. no confirmation of received data but rather 'hail marry' type transmissions you can understand.

The modem will handle the actual transmission, what the Arduino has to do is tell it simply "Hey modem!, Transmit this xyz on channel xyz" The modem handles the formatting from there.

[chastings]

So all you really need is to use an MCU to send a few bytes to the modem, and the modem handles everything else?

A datasheet for the STX2 modem would be very useful.

[kevin286]

So all you really need is to use an MCU to send a few bytes to the modem, and the modem handles everything else?

A datasheet for the STX2 modem would be very useful.

That's right. I know this has got to be simple, but I just don't have enough experience with C/arduino to figure out how to do it. I think the CRC will be the trickiest part but I should just be able to copy and paste it from the datasheet.
I'll upload when I get home.

[kevin286]

Okay, user manual for the satellite modem up on rapidshare.
Download link

Section 4 starting on page 12 explains the serial communications.

On the PCB I etched for it, I pinned out RX, TX, CTS, RTS, VDIG, VREF, OCOUT, TEST1, TEST2, GND which I believe will be more than sufficient.

What else?

[chastings]

A few comments:

1) The Arduino is 5V IO, while it looks like the sat modem is 3.0V IO. You'll need a level shifter in between.

2) Did you bring out the RFOUT pin? This is a 50-ohm impedance line. You want to make it as short as possible and probably connect it to an SMA jack.

3) Pay attention to your ground plane and power supply decoupling. If you did a 2-sided PCB, make the bottom a solid plane connected to ground. Make all of the top side that's unused into a big ground trace.

[kevin286]

A few comments:

1) The Arduino is 5V IO, while it looks like the sat modem is 3.0V IO. You'll need a level shifter in between.

2) Did you bring out the RFOUT pin? This is a 50-ohm impedance line. You want to make it as short as possible and probably connect it to an SMA jack.

3) Pay attention to your ground plane and power supply decoupling. If you did a 2-sided PCB, make the bottom a solid plane connected to ground. Make all of the top side that's unused into a big ground trace.

All good points chastings. I did notice that the modem is TTL 3.3v although the RX pin is 5 volt tolerant. I have directions to make a level shifter I believe somewhere. I did indeed pin out the RFOUT, following the specs for a 50ohm trace. Bottom of the PCB is the ground plane of recommended dimensions. Actually, I've made all of my PCBs out of scrapped antenna ground planes for this type of device.
I think I'll try to work on some code this weekend and post it up for ya'll to scoff at. I really have no idea how to handle the CTS RTS sections of the serial communications. I've found lots of sample code using the softSerial library I believe, but it seems to use only 2 lines, RX and TX.
Anyways, thanks for all the comments, and keep them coming please.

[chastings]

I missed that the inputs are 5V tolerant; you're right that you won't need a level shifter.

RTS# and CTS# (#'s added to denote inverted logic) are "request to send" and "clear to send" flow control signals. The MCU will say to the modem "hey, can you accept a command right now?" by asserting (low) RTS#. If the modem is ready for data, it will assert (low) CTS#, and then you can send a packet.

On the AVR there are no specific CTS or RTS signals associated with the UART. You can just use any two IO pins.

See Figure 8 in section 4.1 of the modem datasheet for some waveforms.

[kevin286]

This weekend I didn't have as much time as I'd liked to learn but I did read through the softwareSerial tutorial page here and it is starting to make sense. I also read through lady ada's AF_softSerial examples here, but those seemed more dedicated to the xport and I wasn't able to pull out what would pertain to general serial communication and what was specific to the xport (probably due to my noobness).

Anywho, I will continue reading and trying to learn how to 'talk'.

Here's the start of the code, with 99% of it just being explanation. Please help out if you can.
Thanks!

Code: Select all

/*
A half-duplex (0-3.0V) TTL asynchronous serial port (UART)
is the primary interface to the user equipment.
The RX data input and the RTS inputs are 5V tolerant.
The TX data and CTS outputs are 0-3.0V TTL.

The serial port works with the serial parameters of:
9600bps, 8 data bits, no parity, 1 stop bit.

In order to wake up the modem (STX2) from sleep mode and to indicate
the end of the serial packet, each serial packet must be framed by
activating RTS before the first byte of the command and deactivating
RTS after the last byte of the command.

********************STX Available***************************************
power __|-----------------------------------------------------------|___
RTS   --|____________|--------------------------------------------------
CTS   ----|____________|------------------------------------------------
TX    ----<     Cmd    >------------------------------------------------
RX    ------------------------< Answer >--------------------------------

*****************STX Busy***********************************************
power __|------------------------------------------------------------|__
RTS   -------|__|-------------------------------------------------------
CTS   __________________________________________________________________
TX    __________________________________________________________________
RX    __________________________________________________________________

The following flowchart and comments illustrate the functional behavior of the unit.
• The senor interface (DTE), in my particular case the DTE is an Arduino, applies power to the STX2. After being powered on, the STX2 remains in a very low
power mode called “Standby Mode”
• When a command needs to be sent, the DTE activates the RTS line. This wakes up the STX2.
• If the STX2 responds by activating the CTS line within 20 ms, it is ready to accept data and
communicate with the DTE
• The DTE provides a serial port packet thru the serial port
• The DTE deactivates the RTS line
• The STX2 deactivates the CTS line
• The STX2 sends a Response Serial Packet
• If the serial packet was a “Transmit Packet”, the STX2 then starts the first transmission attempt
of the packet.
• The STX2 performs its programmed number of attempts
• Once completed the STX2 returns to “Standby Mode”
Notes:
• The DTE shall not activate RTS less than 1sec after the power is applied to the STX2
• If 20 ms after activating RTS, the STX2 does not activate CTS, the DTE will consider
that the modem is busy and will deactivate RTS.
• The modem is typically busy when actively sending a packet.

The serial packet format is as follows:
|--------|------|------|-----------------------|-------|
|Preamble|Length|Cmd   |           Data        |  CRC  |
|(1 byte |1 byte|1 byte|      (<=9 bytes)      |2 bytes|
|--------|------|------|-----------------------|-------|

Preamble = Fixed pattern 0xAA
Length   = Total number of bytes in the serial packet including the preamble
Cmd      = Command type (See Table 7, Serial Packet Type). Responses to
commands carry the same command type as the command that initiated the answer
Data     = Data associated with the command or answer
CRC      = 16 Bit CRC

Notes:

• If not enough bytes are sent to fill the User Information in an Air Interface Packet,
remaining bits are filled with 0.
• If the RTS line is deactivated before the number of bytes specified in the Length field
is received by the STX2. The command is ignored by the STX2.
• No pending message or packet is stored in the STX2 memory once the power has been removed
from the STX2.
• After activating the RTS line, the user equipment should check for the CTS level. Any
serial packet sent without the CTS activated is ignored.
• If the CTS is not activated within 20 ms, the user equipment shall assume that the modem
is unavailable.
/*******************************************************************************
* COMPONENT NAME:
* crc16
*
* DESCRIPTION:
* This function computes a 16 bit CRC value for an array of bytes. The value that is returned by this
* function needs to be inverted before it gets placed into the packet. The CRC
* goes at the end of the packet, low byte first. For example:
*
* crc = ~crc16(0xFFFF, msgbuf, length);
*
* msgbuf[length] = (uint8_t)(crc & 0xFF);
* msgbuf[length + 1] = (uint8_t)(crc >> 8);
*
* When calling this function to check the validity of a packet received from
* the STX2, the caller should expect the value 0xF0B8 (#defined as CRC_OK) to
* be returned if the packet is valid.
*
* INPUTS:
* crc - the value to start computing the CRC with. This allows for chaining
* together of CRC values computed for multiple arrays of data. The
* initial value should be FFFFh (#defined as CRC_INIT).
* ptr - the pointer to the array of bytes to compute the CRC for
* length - the length of the data array
*
* OUTPUTS:
* returns - the computed 16 bit crc value
*******************************************************************************
uint16_t crc16(uint16_t crc, uint8_t *ptr, int length)
{
auto uint16_t i;
while(length--)
{
crc = crc ^ (uint16_t) *ptr++;
for(i=0;i<8;i++)
{
if(crc & 0x0001)
crc = (crc >> 1) ^ 0x8408;
else
crc >>= 1;
}
}
return crc;
}

***CRC Usage Example*********************************************
The following code was compiled using Visual C++ 6.0

//Sample results:
//0xAA 0x05 0x05 CRC : 0x74 0x93
//0xAA 0x05 0x01 CRC : 0x50 0xD5

#include "stdafx.h"
#define uint16_t unsigned short
#define uint8_t unsigned char
int main()
{
unsigned char Input[5];
uint16_t CrcValue=0;
for(;;)
{
Input[0]=0xAA;
Input[1]=0x05;
Input[2]=0x01;
Input[3]=0x00;
Input[4]=0x00;
CrcValue=~crc16(0xFFFF,Input,3);
Input[3]=(uint8_t) (CrcValue&0xFF);
Input[4]=(uint8_t) (CrcValue>>8);
}
printf("That’s done!\n");
return 0;
}
***************************************************************

STX power is 3.3v
Arduino | STX
----->TX
<-----RX
----->RTS
<-----CTS

*/
//BEGIN ACTUAL PROGRAM

byte STX_RXpin = 6; //define the rx pin
byte STX_TXpin = 7;
byte STX_CTSpin = 8; //cts and rts will only be low or high should these be byte?
byte STX_RTSpin = 9;

void setup()
{
  pinMode(STX_RXpin,INPUT);
  pinMode(STX_TXpin,OUTPUT);
  stx_begin(9600);
 
 



[kevin286]

More code.
Somehow I think I may need to have an IF statement for the RTS/CTS. Something like:

If RTS is flipped low and the interval between CTS going low is > 20ms then don't do anything, but if not, E.G. it's less that 20ms then transmit data to the stu.

Code: Select all

/*
A half-duplex (0-3.0V) TTL asynchronous serial port (UART)
is the primary interface to the user equipment.
The RX data input and the RTS inputs are 5V tolerant.
The TX data and CTS outputs are 0-3.0V TTL.

The serial port works with the serial parameters of:
9600bps, 8 data bits, no parity, 1 stop bit.

In order to wake up the modem (STX2) from sleep mode and to indicate
the end of the serial packet, each serial packet must be framed by
activating RTS before the first byte of the command and deactivating
RTS after the last byte of the command.

********************STX Available***************************************
power __|-----------------------------------------------------------|___
RTS   --|____________|--------------------------------------------------
CTS   ----|____________|------------------------------------------------
TX    ----<     Cmd    >------------------------------------------------
RX    ------------------------< Answer >--------------------------------

*****************STX Busy***********************************************
power __|------------------------------------------------------------|__
RTS   -------|__|-------------------------------------------------------
CTS   __________________________________________________________________
TX    __________________________________________________________________
RX    __________________________________________________________________

The following flowchart and comments illustrate the functional behavior of the unit.
• The senor interface (DTE), in my particular case the DTE is an Arduino, applies power to the STX2. After being powered on, the STX2 remains in a very low
power mode called “Standby Mode”
• When a command needs to be sent, the DTE activates the RTS line. This wakes up the STX2.
• If the STX2 responds by activating the CTS line within 20 ms, it is ready to accept data and
communicate with the DTE
• The DTE provides a serial port packet thru the serial port
• The DTE deactivates the RTS line
• The STX2 deactivates the CTS line
• The STX2 sends a Response Serial Packet
• If the serial packet was a “Transmit Packet”, the STX2 then starts the first transmission attempt
of the packet.
• The STX2 performs its programmed number of attempts
• Once completed the STX2 returns to “Standby Mode”
Notes:
• The DTE shall not activate RTS less than 1sec after the power is applied to the STX2
• If 20 ms after activating RTS, the STX2 does not activate CTS, the DTE will consider
that the modem is busy and will deactivate RTS.
• The modem is typically busy when actively sending a packet.

The serial packet format is as follows:
|--------|------|------|-----------------------|-------|
|Preamble|Length|Cmd   |           Data        |  CRC  |
|(1 byte |1 byte|1 byte|      (<=9 bytes)      |2 bytes|
|--------|------|------|-----------------------|-------|

Preamble = Fixed pattern 0xAA
Length   = Total number of bytes in the serial packet including the preamble
Cmd      = Command type (See Table 7, Serial Packet Type). Responses to
commands carry the same command type as the command that initiated the answer
Data     = Data associated with the command or answer
CRC      = 16 Bit CRC

Notes:

• If not enough bytes are sent to fill the User Information in an Air Interface Packet,
remaining bits are filled with 0.
• If the RTS line is deactivated before the number of bytes specified in the Length field
is received by the STX2. The command is ignored by the STX2.
• No pending message or packet is stored in the STX2 memory once the power has been removed
from the STX2.
• After activating the RTS line, the user equipment should check for the CTS level. Any
serial packet sent without the CTS activated is ignored.
• If the CTS is not activated within 20 ms, the user equipment shall assume that the modem
is unavailable.
/*******************************************************************************
* COMPONENT NAME:
* crc16
*
* DESCRIPTION:
* This function computes a 16 bit CRC value for an array of bytes. The value that is returned by this
* function needs to be inverted before it gets placed into the packet. The CRC
* goes at the end of the packet, low byte first. For example:
*
* crc = ~crc16(0xFFFF, msgbuf, length);
*
* msgbuf[length] = (uint8_t)(crc & 0xFF);
* msgbuf[length + 1] = (uint8_t)(crc >> 8);
*
* When calling this function to check the validity of a packet received from
* the STX2, the caller should expect the value 0xF0B8 (#defined as CRC_OK) to
* be returned if the packet is valid.
*
* INPUTS:
* crc - the value to start computing the CRC with. This allows for chaining
* together of CRC values computed for multiple arrays of data. The
* initial value should be FFFFh (#defined as CRC_INIT).
* ptr - the pointer to the array of bytes to compute the CRC for
* length - the length of the data array
*
* OUTPUTS:
* returns - the computed 16 bit crc value
*******************************************************************************
uint16_t crc16(uint16_t crc, uint8_t *ptr, int length)
{
auto uint16_t i;
while(length--)
{
crc = crc ^ (uint16_t) *ptr++;
for(i=0;i<8;i++)
{
if(crc & 0x0001)
crc = (crc >> 1) ^ 0x8408;
else
crc >>= 1;
}
}
return crc;
}

***CRC Usage Example*********************************************
The following code was compiled using Visual C++ 6.0

//Sample results:
//0xAA 0x05 0x05 CRC : 0x74 0x93
//0xAA 0x05 0x01 CRC : 0x50 0xD5

#include "stdafx.h"
#define uint16_t unsigned short
#define uint8_t unsigned char
int main()
{
unsigned char Input[5];
uint16_t CrcValue=0;
for(;;)
{
Input[0]=0xAA;
Input[1]=0x05;
Input[2]=0x01;
Input[3]=0x00;
Input[4]=0x00;
CrcValue=~crc16(0xFFFF,Input,3);
Input[3]=(uint8_t) (CrcValue&0xFF);
Input[4]=(uint8_t) (CrcValue>>8);
}
printf("That’s done!\n");
return 0;
}
***************************************************************

STX power is 3.3v
Arduino | STX
----->TX
<-----RX
----->RTS
<-----CTS

*/
#include <SoftwareSerial.h>

#define rxPin 6
#define txPin 7
#define ctsPin 8
#define rtsPin 9
#define ledPin 13
#define askesn 01

//Setup soft serial port
SoftwareSerial mySerial(rxPin, txPin);

//define pin modes for tx, rx
void setup()
{
  pinMode(rxPin,INPUT);
  pinMode(txPin,OUTPUT);
  pinMode(ctsPin,INPUT);
  pinMode(rtsPin,OUTPUT);
  pinMode(ledPin,OUTPUT);

//set txPin High (as recommended in forum)
digitalWrite(txPin, HIGH);
//set the data rates
mySerial.begin(9600);
Serial.begin(9600);

Serial.println("Hello World");
}

void loop()
{
  //ask the stu what it's esn is
  mySerial.print(askesn, HEX);
 
  char someChar = '0';
  someChar = mySerial.read();
 
  //print what was read through arduino to pc serial port
  Serial.print(someChar, DEC);
 
  //wait 5 seconds before running again
  delay(5000);
 

}
 
 



[kevin286]

I'm building a little serial breakout board so that I can talk to the satellite transmitter with my PC before attempting with the Arduino. This way I can verify that the transmitter is working before connecting with the Atmel.
Like the others I made this using thermal transfer and acid to etch.
Pictures Here

Edit: pictures updated with (most) components populated

[mzapatasilva]

I am working with a Compass that communicates via AF_softserial with the Arduino, and a PC (usb laptop) that talks to Arduino too, and I am running into some timings problems too.

My suggestion is to check if an external UART bufferd, will make your code more simple, and your circuit more robust. This way you don´t have to take care of timings.

MZS

[kevin286]

I am working with a Compass that communicates via AF_softserial with the Arduino, and a PC (usb laptop) that talks to Arduino too, and I am running into some timings problems too.

My suggestion is to check if an external UART bufferd, will make your code more simple, and your circuit more robust. This way you don´t have to take care of timings.

MZS

mzapatasilva, could you post up some sample code please. Does your compass use RTS CTS lines as well or not?

What is a "UART buffered"?

Thanks