Перейти к основному содержимому

Работа со Spacewire

Каналы SpaceWire в составе микросхем серии «Мультикор» имеют ряд особенностей по сравнению с другими периферийными портами. По этой причине описание работы с ними вынесено в отдельный документ. Основная информация по каналам SpaceWire и их реализации в конкретной микросхеме содержится, соответственно, в стандарте интерфейса SpaceWire (и протокола RMAP), а также в руководстве пользователя на рассматриваемую микросхему. Здесь же рассмотрены основные моменты, необходимые для понимания принципов работы с каналами SpaceWire в составе микросхем серии «Мультикор».

Структура и основные принципы работы контроллера Spacewire​

Рисунок 1. Структурная схема контроллера одного канала SpaceWire в микросхеме 1892ВМ12Т

Как видно из рисунка, контроллер SpaceWire состоит из нескольких основных блоков: Блоки Link Interface и LVDS реализуют непосредственно порт SpaceWire, задача которого – переправлять данные между внутренними FIFO микросхемы и линиями канала SpaceWire.

Блоки TX_BUFFER и RX_BUFFER – содержат в своем составе FIFO приема и передачи соответственно. Причем в каждом из направлений есть FIFO данных и FIFO дескрипторов. Этот момент будет рассмотрен далее, а пока можно принять эту информацию к сведению. Блок DMA осуществляет связь буферов с памятью, где хранятся передаваемые данные (или сохраняются принятые).

Здесь следует оговориться, что DMA – это единственный путь передать данные из памяти в канал SpaceWire или обратно. В этом одно из отличий SpaceWire от других периферийных интерфейсов в составе процессоров «Мультикор», где существует возможность программного доступа к буферу устройства без участия DMA.

Блок управления содержит в себе управляющие и статусные регистры, соответственно задающие режим работы блока и содержащие информацию о состоянии всех остальных блоков.

Установка соединения​

Канал SpaceWire для передачи данных должен сначала установить соединение. Без этого передача данных невозможно. Исключение составляет режим однонаправленной передачи, который, однако, достаточно редко используется и в данном случае не рассматривается. Чтобы установить соединение, необходимо, чтобы порт начал посылать в канал служебные символы (подробнее о служебных символах– в стандарте SpaceWire), и начал получать ответный поток символов от второго абонента. Собственно говоря, если данный поток служебных символов прекращается – соединение разрывается.

Чтобы этот поток служебных символов начал передаваться (и, соответственно, приниматься) – необходимо выполнить следующие действия:

  1. Включить PLL, формирующую частоту передачи по SpaceWire и выставить такой множитель PLL, чтобы скорость передачи была равна 10 Мбит/с. Это и предыдущее действие выполняется записью в регистр TX_SPEED. Для процессора 1892ВМ12Т в этот регистр необходимо записать значение 0x302. Биты TX_SPEED[9:8] разрешают работу PLL, а биты TX_SPEED[7:0] содержат множитель. Опорная частота PLL в данном процессоре получается из частоты на входе XTI, поделенной на 4. При частоте XTI 10 МГц опорная частота PLL контроллера SpaceWire – 2,5 МГц, поэтому равна 5 Мбит/с*TX_SPEED[7:0]. Соединение должно устанавливать только на частоте 10 Мбит/с;
  2. В управляющем регистре установить в ноль разряд «LinkDisabled» и установить в единицу разряды LinkStart и/или AutoStart. Если установить в единицу только бит AutoStart – порт SpaceWire не будет сам отправлять поток служебных символов, пока не получит этих символов от второго абонента. В случае установки только LinkStart – порт начнет отправлять поток служебных символов сразу.
  3. Далее порт SpaceWire пытается установить соединение. Необходимо дождаться, когда оно будет установлено. Об этом сигнализирует поле LINK_STATE в регистре STATUS (разряды [7:5]). Состоянию Run (то есть, установленному соединению) соответствует значение «5».
  4. Далее желательно провести проверку наличия соединения.

Объем проверок для построения отказоустойчивой системы должен включать в себя, как минимум:

  • проверку значения регистра RX_SPEED. В регистре RX_SPEED содержится скорость приема данных, вычисляемая аппаратно контроллером SpaceWire;
  • отсылку и прием тестового пакета, подтверждающего наличие соединения. В случае, если от второго абонента не приходит тестовый пакет – считается, что соединения нет. Данное требование не определено стандартом SpaceWire, так как относится к протоколу более высокого уровня. Тем не менее, опыт показывает, что наличие такой проверки крайне желательно.

В процессе установки соединения по каналу SpaceWire периоды отсылки пачек служебных символов чередуются с периодами «молчания», и длительности этих периодов строго заданы в стандарте SpaceWire. В процессорах серии «Мультикор» длительность этих периодов привязана к тактовой частоте CPU-ядра.

По умолчанию подразумевается, что тактовая частота CPU-ядра – 100 МГц, и исходя из этого рассчитывается длительность вышеупомянутых периодов. В случае, если CPU-ядро работает на другой частоте, необходимо записать в поле TIMING регистра TX_SPEED значение тактовой частоты CPU в мегагерцах, поделенное на 10. По умолчанию запись в это поле запрещена, чтобы разрешить ее – необходимо установить в единицу бит COEFF_10_wr регистра MODE_CR. Процедура установки соединения, таким образом, может выглядеть следующим образом:

// частота процессора в МГц
#define CPU_FREQ 80

// таймаут соединения в тактах процессора – 0.1 секунды
#define CONNECT_TIMEOUT ((CPU_FREQ*1000000)/10);

 // функция для отсчета таймаутов
unsigned int GetCP0_Count() {
   unsigned int result;
   asm volatile ("mfc0 %0, $9" :"=r"(result));
   return result;
}

void SWIC_setTiming() {
   MODE_CR |= (1<<14);
   TX_SPEED |= (CPU_FREQ/10)<<20;
   MODE_CR &= ~(1<<14);
}

unsigned int SWIC_tryToConnect() {
   // момент начала установки соединения
   unsigned int start_connect_time;
   SWIC_setTiming();
   // выключаем контроллер и PLL
   TX_SPEED = 0;
   MODE_CR = 0x41;
   // включаем PLL и устанавливаем скорость обмена 10 Мбит/с
   TX_SPEED = 0x302;
   // устанавливаем биты LinkStart и AutoStart
   MODE_CR = 0x6;
   // фиксируем время начала установки соединения
   start_connect_time = GetCP0_Count();
   while ( (STATUS & (0xE0) != 0xA0 )) {
      if (GetCP0_Count()-start_connect_time) > CONNECT_TIMEOUT) {
         break;
      }
   }
   if ( (STATUS & (0xE0) != 0xA0 || (RX_SPEED==0) ) {
   // соединение установить не удалось
      return 0;
   }
   return 1;
}

Соединение не будет установлено, если приемные FIFO канала SpaceWire заполнены данными. Вследствие этого необходимо перед установкой соединения произвести процедуру очистки приемных FIFO:

void SWIC_clearRxFifo() {
   INT csr_rx_des, prev_csr_rx_des=0;
   INT csr_rx_dat, prev_csr_rx_dat=0;
   IR_SWIC_RX_DES = DESC_RX_ADDR;
   IR_SWIC_RX_DAT = DATA_RX_ADDR;
   CSR_SWIC_RX_DES = (0xFFFF<<16) | 1;
   CSR_SWIC_RX_DAT = (0xFFFF<<16) | 1;

   while (1) {
      csr_rx_des = CSR_SWIC_RX_DES;
      if ( (csr_rx_des&(0xFFFF<<16)) == (prev_csr_rx_des&(0xFFFF<<16)) ) {
         break;
      }
      prev_csr_rx_des = csr_rx_des;
   }

   while (1) {
      csr_rx_dat = CSR_SWIC_RX_dat;
      if ( (csr_rx_dat&(0xFFFF<<16)) == (prev_csr_rx_dat&(0xFFFF<<16)) ) {
         break;
      }
      prev_csr_rx_dat = csr_rx_dat;
   }

   CSR_SWIC_RX_DES = 0;
   CSR_SWIC_RX_DAT = 0;
}

Микросхемы 1892ВМ7Я, 1892ВМ8Я и 1892ХД1Я имеют особенность реализации каналов DMA SpaceWire. Она заключается в том, что когда канал DMA запущен (бит RUN выставлен в единицу), останов канала должен производиться следующим образом:

  • запись нуля в разряд RUN;
  • передача каналом DMA хотя бы одного слова данных.

На практике это значит, что для останова принимающего канала DMA необходимо записать ноль в разряд RUN регистра CSR, после чего дождаться приема служебного пакета со стороны второго абонента. Такой обмен необходимо закладывать в высокоуровневый протокол, используемый в сети.

Установка рабочей скорости обмена​

Для установки требуемой скорости обмена необходимо записать в регистр TX_SPEED соответствующий множитель PLL. Важно понимать, что несмотря на гарантированную способность микросхемы работать на заявленной частоте обмена, многое зависит также от линий передачи. Поэтому выставить множитель PLL – недостаточно для получения требуемой скорости обмена. Необходимо также проконтролировать, что соединение после этого не разорвалось, и только потом приступать непосредственно к пересылке данных. Для проверки состояния соединения необходимо удостовериться, что поле LINK_STATE регистра STATUS по-прежнему соответствует состоянию Run. В случае возникновения флагов ошибок в разрядах STATUS[3:0] необходимо обнулить их. Установка рабочей скорости может быть выполнена, например, так:

// таймаут для проверки соединения в тактах CPU. 0.1 секунда
#define CONNECT_CHECK_TIMEOUT ((CPU_FREQ*1000000)/10)

// параметр – желаемая скорость в мегабитах
unsigned int SWIC_setSpeed(unsigned int speed) {
   unsigned int set_speed_time;
   TX_SPEED = (3<<8) | (speed/5);
   set_speed_time = GetCP0_Count();

   while ( (GetCP0_Count() - set_speed_time) < CONNECT_CHECK_TIMEOUT) {
      if ( STATUS&0xE0 != 0xA0) {
         return 0;
      }
   }

   if ( ( (STATUS&0xE0) != 0xA0) || ( (STATUS&0xF) != 0 ) ) {
      return 0;
   }

   return 1;
}

Передача данных​

Как уже говорилось выше, в отличие от других периферийных портов (например, LPORT, SPI, UART), в канал SpaceWire нельзя отправить «просто байт» или «просто слово». Это связано с тем, что SpaceWire, в отличие от упомянутых интерфейсов, оперирует понятием «пакет данных». Пакет в терминологии SpaceWire – это последовательность байтов данных с завершающим символом конца пакета (это специальный служебный символ). Конец пакета может быть корректным (символ EOP – End of packet) или некорректным (символ EEP – Error end of packet). Подробнее о символах и их представлении рассказано в стандарте SpaceWire.

В силу вышеизложенных причин, принята следующая концепция: контроллер SpaceWire должен получить так называемый дескриптор для передачи, в котором будет указано количество байт для передачи в канал. После этого контроллер начнет пересылать приходящие из памяти данные в канал. Когда будет передано заданное количество байт – контроллер сформирует символ конца пакета EOP и также передаст его в канал. Поэтому в реализации SpaceWire в микросхемах серии «Мультикор» блок TX_BUFFER содержит в своем составе два FIFO. Одно FIFO (FIFO данных) принимает данные из памяти и готовит их для передачи в канал. Второе FIFO (FIFO дескрипторов) принимает из памяти дескрипторы для передачи.

В случае, когда в FIFO дескрипторов передается один дескриптор, контроллер SpaceWire расшифровывает его, после чего готов к передаче заданного числа байт. Каждое слово, пришедшее в FIFO данных, передается в канал SpaceWire, до тех пор, пока не будет передано заданное число байт. Если в FIFO данных пришло меньшее количество данных – контроллер SpaceWire будет ожидать получения следующей порции данных, не отправляя в канал символ конца пакета. Если в FIFO данных пришло большее количество данных – в канал будет отправлено то количество байт, которое указано в дескрипторе. Все остальные данные останутся в FIFO данных до получения следующего дескриптора.

Доступ к FIFO дескрипторов и данных SpaceWire возможен только со стороны каналов DMA. Для передачи данных и дескрипторов имеются отдельные каналы DMA. Ниже приведен пример кода, отсылающего пакет в канал SpaceWire. Следует учитывать, что каналы DMA SpaceWire в микросхемах серии «Мультикор» оперируют 32- и 64-разрядными словами. Адрес начала пакета в памяти должен быть выровнен по границе соответствующего слова. Пример функции, отсылающей пакет, приведен ниже.

// длина пакета в байтах
#define ARRAY_LEN 256
// адрес выровнен по границе 64-разрядного слова
unsigned char swic_packet[ARRAY_LEN] __attribute__ ((aligned(8)));
// параметры – указатель на адрес передаваемых данных и
// длина передаваемого массива в байтах
void SWIC_sendPacket(unsigned int *array, unsigned int len) {
   // дескриптор тоже передается посредством DMA
   // поэтому его адрес тоже должен быть выровнен
   unsigned int descriptor[2] __attribute__ ((aligned(8)));
   // формируем дескриптор
   descriptor[0] = 0xA0000000 | len;
   // задаем адрес дескриптора для канала DMA дескрипторов
   // каналы DMA оперируют физическими адресами
   IR_SWIC_TX_DES0 = get_phy_addr((unsigned int) descriptor);
   // задаем адрес начала пакета для канала DMA данных
   IR_SWIC_TX_DAT0 = get_phy_addr((unsigned int) array);
   // запускаем канал DMA дескрипторов на передачу одного слова
   // поле WCX=0 – одно слово для передачи
   // поле RUN=1 – передача запущена
   CSR_SWIC_TX_DES0 = 1;
   // запускаем канал DMA данных на передачу
   // поле WCX=(len/8-1) – канал DMA оперирует 64-разрядными словами
   // значение должно быть на единицу меньше, чем количество
   // передаваемых слов
   CSR_SWIC_TX_DAT0 = ((len/8-1)<<16) | 1;
   // ожидаем окончания работы DMA данных
   while (RUN_SWIC_TX_DAT0&1) ; // пока выставлен бит Run
   // канал DMA отработал, дожидаемся, чтоб данных в FIFO SpaceWire
   // также не осталось
   while ( !( STATUS & (1<<11) ) ) ; // пока не станет нулем бит TX_BUF_EMPTY
}

Приведенный алгоритм требует следующих замечаний:

  1. Ожидается именно окончание работы канала DMA данных. Окончание работы канала DMA дескрипторов не гарантирует, что пересылка данных хотя бы началась;
  2. В ряде случае требуется во время отсылки данных выполнять другие действия. Реализация неблокирующего вызова функции SWIC_sendPacket будет зависеть от конкретной системы, в которой она будет использоваться. Как правило, для этого используются прерывания. В частности, может использоваться прерывание от канала DMA данных;
  3. Дескриптор задается в виде массива из двух 32-разрядных слов. Так как DMA оперирует 64-разрядными словами, передаваться в контроллер SpaceWire будут оба слова. При этом использоваться будет только младшее (расположенное по младшему адресу). Второе слово объявляется для прозрачности.
  4. Алгоритм будет некорректно работать в случае, если длина пакета не кратна 8 байтам. В этом случае необходимо задавать в поле WCX на одно слово больше. Алгоритм с учетом этого выглядит так:
void SWIC_sendPacket(unsigned int *array, unsigned int len) {
   // дескриптор тоже передается посредством DMA
   // поэтому его адрес тоже должен быть выровнен
   unsigned int descriptor[2] __attribute__ ((aligned(8)));
   // формируем дескриптор
   descriptor[0] = 0xA0000000 | len;
   // задаем адрес дескриптора для канала DMA дескрипторов
   // каналы DMA оперируют физическими адресами
   IR_SWIC_TX_DES0 = get_phy_addr((unsigned int) descriptor);
   // задаем адрес начала пакета для канала DMA данных
   IR_SWIC_TX_DAT0 = get_phy_addr((unsigned int) array);
   // запускаем канал DMA дескрипторов на передачу одного слова
   // поле WCX=0 – одно слово для передачи
   // поле RUN=1 – передача запущена
   CSR_SWIC_TX_DES0 = 1;
   // запускаем канал DMA данных на передачу
   // поле WCX=(len/8-1) – канал DMA оперирует 64-разрядными словами
   // значение должно быть на единицу меньше, чем количество
   // передаваемых слов
   if (len%8) {// если длина не кратна 8 байтам
      CSR_SWIC_TX_DAT0 = ((len/8)<<16) | 1;
   }
   else {
      CSR_SWIC_TX_DAT0 = ((len/8-1)<<16) | 1;
   }
   // ожидаем окончания работы DMA данных
   while (RUN_SWIC_TX_DAT0&1) ; // пока выставлен бит Run
   // канал DMA отработал, дожидаемся, чтоб данных в FIFO SpaceWire
   // также не осталось
   while ( !( STATUS & (1<<11) ) ) ; // пока не станет нулем бит TX_BUF_EMPTY
}

void SWIC_sendPacket(unsigned int *array, unsigned int len) {
   // дескриптор тоже передается посредством DMA
   // поэтому его адрес тоже должен быть выровнен
   unsigned int descriptor[2] __attribute__ ((aligned(8)));
   // формируем дескриптор
   descriptor[0] = 0xA0000000 | len;
   // задаем адрес дескриптора для канала DMA дескрипторов
   // каналы DMA оперируют физическими адресами
   IR_SWIC_TX_DES0 = get_phy_addr((unsigned int) descriptor);
   // задаем адрес начала пакета для канала DMA данных
   IR_SWIC_TX_DAT0 = get_phy_addr((unsigned int) array);
   // запускаем канал DMA дескрипторов на передачу одного слова
   // поле WCX=0 – одно слово для передачи
   // поле RUN=1 – передача запущена
   CSR_SWIC_TX_DES0 = 1;
   // запускаем канал DMA данных на передачу
   // поле WCX=(len/8-1) – канал DMA оперирует 64-разрядными словами
   // значение должно быть на единицу меньше, чем количество
   // передаваемых слов
   if (len%8) {// если длина не кратна 8 байтам
      CSR_SWIC_TX_DAT0 = ((len/8)<<16) | 1;
   }
   else {
      CSR_SWIC_TX_DAT0 = ((len/8-1)<<16) | 1;
   }
   // ожидаем окончания работы DMA данных
   while (RUN_SWIC_TX_DAT0&1) ; // пока выставлен бит Run
   // канал DMA отработал, дожидаемся, чтоб данных в FIFO SpaceWire
   // также не осталось
   while ( !(STATUS & (1<<11) ) ) ; // пока не станет нулем бит TX_BUF_EMPTY
}

Прием данных​

Прием данных по каналам SpaceWire осуществляется следующим образом. После приема каждого из символов контроллер SpaceWire определяет, является ли он служебным символом или символом данных. Если это символ данных – он передается в FIFO данных, а счетчик байтов данных будет инкрементирован. Если это служебный символ конца пакета (EOP или EEP) – будет сформирован дескриптор с соответствующим признаком валидности. В поле длины будет сохранено значение счетчика байт данных. Сформированный дескриптор будет передан в FIFO дескрипторов. Поведение контроллера при приеме других служебных символов рассмотрено в отдельном разделе.

Таким образом, задача приема данных по SpaceWire сводится к запуску принимающих каналов DMA данных и дескрипторов, и последующему ожиданию завершения работы DMA дескрипторов. Если обмен не ведется пакетами фиксированной длины, только формирование дескриптора может служить признаком приема пакета данных. Пока не принят символ EEP или EOP – пакет не принят. В противном случае, можно ожидать и окончания Исходя из этого, функция, осуществляющая прием пакета, может выглядеть так:

// максимальная длина пакета
#define MAX_PACKET_LEN 1024

unsigned char data_buffer[ARRAY_LEN] __attribute__ ((aligned(8)));
   // параметры – адрес приемного буфера,
   // адрес переменной, содержащей длину принятого пакета
   // возвращает 1, если пакет принят нормально (EOP), 0 – если нет (EEP)
   unsigned int SWIC_receivePacket(unsigned int *data_buffer, unsigned int &packet_len) {
   unsigned int descriptor[2] = {0, 0} __attribute__ ((aligned(8)));

   IR_SWIC_RX_DES0 = get_phy_addr((unsigned int) &descriptor);
   IR_SWIC_RX_DAT0 = get_phy_addr((unsigned int) data_buffer);
   CSR_SWIC_RX_DES0 = 1; // прием одного дескриптора (пакета)
   CSR_SWIC_RX_DAT0 = ((MAX_PACKET_LEN/8)<<16) | 1;

   while (RUN_SWIC_RX_DES0&1) ;

   *packet_len = descriptor[0] & 0xFFFFFFF;
   if ( (descriptor[0]&0xF0000000) != 0xA0000000 ) {
      return 0;
   }
   else {
      return 1;
   }
}

Примечания к приведенному алгоритму:

  1. Аналогично алгоритму отсылки пакета, в случае необходимости реализации неблокирующего вызова, это можно реализовать с помощью прерываний, на этот раз – от канала DMA дескрипторов;
  2. Массив для приема дескрипторов явно задается заполненным нулями. Это связано с тем, что в случае приема ошибочного пакета (EEP) разряд 31 дескриптора не обнуляется, что может привести к некорректному результату проверки, если не обнулить этот разряд заранее.

Служебные символы и управляющие коды​

SpaceWire предусматривает несколько служебных символов и управляющих кодов, которые подробно рассмотрены в стандарте. Здесь же будет приведена краткая информация по ним.

СимволОписание
NULLСлужебный символ, передаваемый всегда, когда не передаются данные или другие управляющие коды/служебные символы. Необходим для поддержания соединения (и определения разрыва соединения)
FCT (Flow control token)—
EOP (Normal end of packet)Служебный символ, сообщающий о корректном завершении пакета
EEP (Error end of packet)Служебный символ, сообщающий об ошибочном завершении пакета

Помимо вышеуказанного, в стандарте SpaceWire реализована возможность передачи маркеров времени и кодов распределенных прерываний. С их помощью возможна синхронизация узлов сети между собой. Для передачи маркера времени необходимо записать значение маркера в регистр TX_CODE. После этого, если соединение по каналу SpaceWire установлено, маркер будет немедленно передан в сеть (в случае, если в этот момент происходит передача пакета – она будет приостановлена до завершения передачи маркера времени).

По приему маркера времени контроллер SpaceWire выставляет отдельный флаг в одном из регистров. Данный флаг также транслируется в регистр запросов прерываний. Соответственно, обработка полученного маркера времени возможна по прерыванию. Механизм передачи кодов распределенных прерываний полностью аналогичен механизму передачи маркеров времени.

Коммутация пакетов Spacewire и протокол RMAP​

Поскольку SpaceWire является интерфейсом типа «точка-точка», для построения сети с большим количеством абонентов удобнее всего использовать коммутаторы SpaceWire. Коммутаторы SpaceWire в серии «Мультикор» представлены несколькими микросхемами, имеющими в своем составе коммутационную матрицу, управляющее CPU-ядро архитектуры MIPS32 и ряд периферийных блоков, необходимых для подключения ПЗУ (где хранится управляющее ПО коммутатора) и другой обвязки. На сегодняшний день программирование коммутаторов конечным пользователем не предусматривается, к микросхеме предоставляется бинарный файл управляющего ПО коммутатора, который должен быть записан в ПЗУ, подключенное к микросхеме коммутатора. Подробнее об этом написано в соответствующей документации. Здесь же будет чуть подробнее рассказано о маршрутизации в сетях SpaceWire.

Таблица маршрутизации
—АдресПорт 0Порт 1Порт 2Порт 3Порт 4
Внутренний порт конфигурации010000
Физические выходные порты 101000
200100
—
Логические адреса, отображающиеся на физические выходные порты 3201000
3300100
3400001
—
Резервный 25500000

Согласно стандарту SpaceWire, первый байт пакета содержит в себе адрес узла, в который он направлен. В случае приема пакета коммутатором, первый байт рассматривается как номер строки таблицы маршрутизации. Строка таблицы маршрутизации – это слово данных, в котором младшие 16 разрядов соответствуют шестнадцати каналам коммутатора. При получении пакета коммутатор вычитывает строку маршрутизации за номером, соответствующим значению первого байта, после чего направляет данные в каналы с номерами, соответствующими номерам установленных в единицу разрядов вычитанного слова.

При этом буферизации пакета не производится – пакет перенаправляется сразу же после получения первого байта. Первые 16 строк таблицы маршрутизации имеют жестко заданные значения и не могут быть изменены. Строке 1 соответствует первый канал, строке два – второй, и так далее. То есть, пересылка пакета, в котором адресный бит имеет значение от 1 до 16, произойдет только в один канал с соответствующим номером.

Строки 33-255 таблицы маршрутизации могут быть изменены. Поэтому с их помощью можно организоваться широковещательную рассылку по нескольким каналам коммутатора, выставив в единицу несколько бит одновременно.

Помимо этого, коммутаторы SpaceWire реализуют так называемую адаптивную групповую маршрутизацию. Каждому каналу SpaceWire соответствует один регистр ADG_ROUTx (где x – номер канала). Если требуемый канал не соединен или выключен (LinkDisabled=1), коммутатор анализирует регистр ADG_ROUT и перенаправляет пакет в альтернативные каналы, определенные в регистре ADG_ROUT. Подробнее это описано в руководстве пользователя на коммутатор.

Если адресный байт пакета равен нулю – считается, что он адресован в так называемый конфигурационный порт узла SpaceWire. Предполагается в этом случае, что пакет соответствует протоколу RMAP (remote memory access protocol). В зависимости от его содержания, пакет содержит либо данные, подлежащие записи в указанный адрес памяти, либо запрос на получение данных из требуемого адреса памяти.

В коммутаторе SpaceWire использование пакетов RMAP, адресованных в нулевой порт, позволяет изменять таблицу маршрутизации, настройки каналов SpaceWire и еще некоторые параметры. Обработка пакетов RMAP реализована программно на CPU-ядре. В некоторых микросхемах (например, 1892ХД5Т) обработка пакетов RMAP реализована аппаратно. В микросхемах процессоров, содержащих каналы SpaceWire, а также в микросхемах «мостах» (1892ХД1Я, 1892ХД4Ф) аппаратной поддержки RMAP не предусмотрено, она при необходимости должна быть реализована программно в ПО, разрабатываемом пользователем. Протокол RMAP определен стандартом ECSS-E-ST-50-52C, и более подробно описан в нем.

Последнее обновление