logo
+7 (495) 997-37-74
Москва, ул.Международная, 15

ATSHA204A — Запись конфигурации 1

Этой статьёй мы начинаем цикл материалов по записи зоны конфигурации микросхемы ATSHA204A. Ранее в этом руководстве был дан обзор ATSHA204A и в трёх предыдущих статьях было подробно разобрано устройство конфигурационной зоны этого чипа и даны практические примеры чтения из неё различных параметров.

Если вы ещё не знакомы со статьями этого цикла, то перед чтением этого материала рекомендуем вам ознакомиться с ними потому, что в них изложены основы работы с ATSHA204A и без хорошего понимания этих основ вам будет трудно разобраться в текущем материале.

Таблица зоны конфигурации

Для удобства мы приводим здесь таблицу зоны конфигурации микросхемы ATSHA204A. Эта таблица — основа и «ключ» для работы с конфигурационной зоной ATSHA204A.

Поля Serial Number, Revision Number и I2C Enable

В предыдущих статьях мы познакомились с устройством и принципами чтения данных из конфигурационной зоны ATSHA204A, в этой статье мы разберём запись данных в эту зону. Поля Serial Number, Revision Number и I2C Enable мы пропускаем, поскольку согласно информации из даташита и вышеприведённой таблицы, эти поля доступны только для чтения и не доступны для записи.

А начнём мы байта I2C Address.

Запись I2C Address

Как вы помните, байт I2C Address отвечает за номер микросхемы ATSHA204A на шине в режиме работы по I2C интерфейсу, а в случае работы по SWI интерфейсу, в этом байте содержится информация об уровне напряжения логики.

Начнём мы с варианта работы по I2C интерфейсу, вот полный код скетча, осуществляющего запись и изменение байта I2C Address в конфигурационной зоне микросхемы ATSHA204A:

/* 
  ATSHA204 Write Config I2C Address
*/

#include <sha204_library.h>

#define ATSHA204_PIN A3

byte bufTx[SHA204_CMD_SIZE_MAX];
byte bufRx[SHA204_RSP_SIZE_MAX];

byte slot = 4;
byte shift = 0;

byte addrDefault = 0xC8;
byte addrNew = 0x55;

#define SLOT_LEN 4
byte bufRead[SLOT_LEN];
byte bufWrite[SLOT_LEN];

atsha204Class sha204(ATSHA204_PIN);


void setup() {
  Serial.begin(115200);
  Serial.println(F("ATSHA204 Write Config I2C Address start..."));

  Serial.print(F("Slot #"));  Serial.println(slot);

  readSlot();

  seti2cAddress(addrNew);
  writeConfig();
  
  readSlot();
}

// Print

void printBuffer(byte* data, byte len) {
  for (size_t i = 0; i < len; i++) {
    if (data[i] < 10) {Serial.print('0');}
    Serial.print(data[i], HEX);
    if (i < len - 1) {Serial.print(' ');}
  }
}

// Read

void copyReadToWrite() {
  bufWrite[0] = bufRead[0];
  bufWrite[1] = bufRead[1];
  bufWrite[2] = bufRead[2];
  bufWrite[3] = bufRead[3];
}

byte addr(byte slot) {
  return slot * 4;
}

void readConf() {
  byte retCode = sha204.sha204m_read(bufTx, bufRx, SHA204_ZONE_CONFIG, addr(slot));
  bufRead[0] = bufRx[SHA204_BUFFER_POS_DATA + 0];
  bufRead[1] = bufRx[SHA204_BUFFER_POS_DATA + 1];
  bufRead[2] = bufRx[SHA204_BUFFER_POS_DATA + 2];
  bufRead[3] = bufRx[SHA204_BUFFER_POS_DATA + 3];
  
}

void readSlot() {
  readConf();
  copyReadToWrite();
  
  Serial.print(F("Read: "));
  printBuffer(bufRead, SLOT_LEN);
  Serial.println();
}

// Write

void seti2cAddress(byte b) {
  bufWrite[shift] = b;
}

void writeConfig() {
  byte retCode = sha204.sha204m_execute(SHA204_WRITE,
                                        SHA204_ZONE_CONFIG, slot,
                                        4, bufWrite,
                                        0, NULL,
                                        0, NULL,
                                        WRITE_COUNT_SHORT, bufTx,
                                        WRITE_RSP_SIZE,    bufRx);
}

void loop() {

}

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

Итак, объявляем переменные слота и смещения в нём и присваиваем им значения согласно информации из даташита (вышеприведённой таблицы).

byte slot = 4;
byte shift = 0;

Объявляем переменные I2C адреса по умолчанию и нового адреса, который мы запишем в конфигурационную зону ATSHA204A. Новый адрес может быть любым, мы выбрали значение 0x55 просто для примера.

byte addrDefault = 0xC8;
byte addrNew = 0x55;

Поскольку чтение (и запись) в ATSHA204A осуществляется слотами по 4 байта, объявляем два 4-байтовых массива для чтения и записи.

#define SLOT_LEN 4
byte bufRead[SLOT_LEN];
byte bufWrite[SLOT_LEN];

Работа происходит следующим образом: сначала мы читаем исходное состояние слота, затем меняем в нём старый байт I2C Address на новый, производим запись и снова читаем слот, чтобы убедиться, что запись действительно произведена и новое значение соответствует тому, которое мы указали в скетче.

  readSlot();

  seti2cAddress(addrNew);
  writeConfig();
  
  readSlot();

Теперь немного подробнее о процедуре чтения. Блок чтения осуществляется функцией readSlot().

void readSlot() {
  readConf();
  copyReadToWrite();
  
  Serial.print(F("Read: "));
  printBuffer(bufRead, SLOT_LEN);
  Serial.println();
}

Вначале мы читаем слот памяти, согласно даташита на ATSHA204A. Эту функцию мы не будем здесь рассматривать подробно, поскольку делали это в предыдущих статьях.

readConf();

А затем копируем содержимое прочитанного массива в приёмный массив для будущей записи.

void copyReadToWrite() {
  bufWrite[0] = bufRead[0];
  bufWrite[1] = bufRead[1];
  bufWrite[2] = bufRead[2];
  bufWrite[3] = bufRead[3];
}

И выводим в Serial информацию о прочитанном слоте.

  Serial.print(F("Read: "));
  printBuffer(bufRead, SLOT_LEN);
  Serial.println();

Затем устанавливаем требуемый байт в слоте (согласно инфорации из даташита) в нужное нам состояние.

  seti2cAddress(addrNew);

В массиве для записи меняем байт по смещению shift на нужный нам (адрес на шине I2C).

void seti2cAddress(byte b) {
  bufWrite[shift] = b;
}

И производим собственно запись при помощи функции writeConfig().

void writeConfig() {
  byte retCode = sha204.sha204m_execute(SHA204_WRITE,
                                        SHA204_ZONE_CONFIG, slot,
                                        4, bufWrite,
                                        0, NULL,
                                        0, NULL,
                                        WRITE_COUNT_SHORT, bufTx,
                                        WRITE_RSP_SIZE,    bufRx);
}

Эта функция использует множество параметров, более подробно с её устройством вы можете ознакомиться в предыдущих статьях этого цикла. В случае успешной записи функция возвращает 0, в случае возникновения проблем — код ошибки.

Далее ещё раз производится контрольное чтение слота. Вот скриншот результата работы нашего скетча:

Старое значение байта I2C Address 0xC8 успешно заменено на 0x55.

Запись TTL Enable

Теперь разберём изменение байта I2C Address в режиме работы микросхемы ATSHA204A по SWI интерфейсу. В этом случае меняется тот же байт (по тому же адресу слот/смещение), но существенным является состояние 3-го бита этого байта. Если 3-й бит равен 1, то используется VCC уровень напряжения (уровень источника питания) логики (по умолчанию), а если 0, то фиксированный TTL уровень.

Полный код скетча ATSHA204 Write Config TTL Enable:

/* 
  ATSHA204 Write Config TTL Enable
*/

#include <sha204_library.h>

#define ATSHA204_PIN A3

byte bufTx[SHA204_CMD_SIZE_MAX];
byte bufRx[SHA204_RSP_SIZE_MAX];

byte slot = 4;
byte shift = 0;

byte swiTtl = 0x00;
byte swiVcc = 0x08;

#define SLOT_LEN 4
byte bufRead[SLOT_LEN];
byte bufWrite[SLOT_LEN];

atsha204Class sha204(ATSHA204_PIN);


void setup() {
  Serial.begin(115200);
  Serial.println(F("ATSHA204 Write Config TTL Enable start..."));

  Serial.print(F("Slot #"));  Serial.println(slot);

  readSlot();

  seti2cAddress(swiTtl);
  writeConfig();
  
  readSlot();
  Serial.print(F("Bit #3: ")); Serial.println(bitRead(bufWrite[shift], 3));
}

// Print

void printBuffer(byte* data, byte len) {
  for (size_t i = 0; i < len; i++) {
    if (data[i] < 10) {Serial.print('0');}
    Serial.print(data[i], HEX);
    if (i < len - 1) {Serial.print(' ');}
  }
}

// Read

void copyReadToWrite() {
  bufWrite[0] = bufRead[0];
  bufWrite[1] = bufRead[1];
  bufWrite[2] = bufRead[2];
  bufWrite[3] = bufRead[3];
}

byte addr(byte slot) {
  return slot * 4;
}

void readConf() {
  byte retCode = sha204.sha204m_read(bufTx, bufRx, SHA204_ZONE_CONFIG, addr(slot));
  bufRead[0] = bufRx[SHA204_BUFFER_POS_DATA + 0];
  bufRead[1] = bufRx[SHA204_BUFFER_POS_DATA + 1];
  bufRead[2] = bufRx[SHA204_BUFFER_POS_DATA + 2];
  bufRead[3] = bufRx[SHA204_BUFFER_POS_DATA + 3];
  
}

void readSlot() {
  readConf();
  copyReadToWrite();
  
  Serial.print(F("Read: "));
  printBuffer(bufRead, SLOT_LEN);
  Serial.println();
}

// Write

void seti2cAddress(byte b) {
  bufWrite[shift] = b;
}

void writeConfig() {
  byte retCode = sha204.sha204m_execute(SHA204_WRITE,
                                        SHA204_ZONE_CONFIG, slot,
                                        4, bufWrite,
                                        0, NULL,
                                        0, NULL,
                                        WRITE_COUNT_SHORT, bufTx,
                                        WRITE_RSP_SIZE,    bufRx);
}

void loop() {

}

Объявляем переменную swiTtl равную 0x00 (нулю).

byte swiTtl = 0x00;

И переменную swiVcc равную 0x08 (в двоичном представлении 0b00001000, то есть единица в 3-м бите).

byte swiVcc = 0x08;

И записываем байт swiTtl на место I2C Address в конфигурационной зоне микросхемы ATSHA204A.

  seti2cAddress(swiTtl);

Результат работы этого скетча, байт записан, бит 3 равен нулю, то есть микросхемой будет использоваться уровень логики TTL.

Изменим байт swiTtl на swiVcc и получаем установку работы логики микросхемы ATSHA204A от напряжения источника питания VCC.

  seti2cAddress(swiVcc);
 

Запись CheckMacConfig

Байт CheckMacConfig — это байт настройки режимов работы команд CheckMac, Read и Write, в котором каждый бит отвечает за настройки соответствующего слота (слотов).

Относительно команд Read и Write:

Бит 0 управляет слотами 0 и 1
Бит 1 управляет слотами 2 и 3
Бит 2 управляет слотами 4 и 5
Бит 3 управляет слотами 6 и 7
Бит 4 управляет слотами 8 и 9
Бит 5 управляет слотами 10 и 11
Бит 6 управляет слотами 12 и 13
Бит 7 управляет слотами 14 и 15

Любая зашифрованная команда чтения/записи завершится неудачей, если значение в TempKey.SourceFlag не совпадёт с соответствующим битом в этом байте. Байт CheckMacConfig игнорируется при чтении и записи открытого текста.

Относительно команды CheckMac:

Бит 0 управляет слотом 1
Бит 1 управляет слотом 3
Бит 2 управляет слотом 5
Бит 3 управляет слотом 7
Бит 4 управляет слотом 9
Бит 5 управляет слотом 11
Бит 6 управляет слотом 13
Бит 7 управляет слотом 15

Копирование будет возможно только в том случае, если значение CheckMacSource целевого слота соответствует значению бита 2 режима команды CheckMac. Команда не будет выполнена, если бит 2 режима не соответствует TempKey.SourceFlag.

Теперь создадим скетч, который, для примера, изменяет 4 первых бита байта CheckMacConfig в конфигурационной зоне ATSHA204A на единицы. Полный код скетча:

/* 
  ATSHA204 Write Config CheckMacConfig
*/

#include <sha204_library.h>

#define ATSHA204_PIN A3

byte bufTx[SHA204_CMD_SIZE_MAX];
byte bufRx[SHA204_RSP_SIZE_MAX];

byte slot = 4;
byte shift = 1;

byte testByte = 0x0F;

#define SLOT_LEN 4
byte bufRead[SLOT_LEN];
byte bufWrite[SLOT_LEN];

atsha204Class sha204(ATSHA204_PIN);


void setup() {
  Serial.begin(115200);
  Serial.println(F("ATSHA204 Write Config CheckMacConfig start..."));

  Serial.print(F("Slot #"));  Serial.println(slot);

  readSlot();

  seti2cAddress(testByte);
  writeConfig();
  
  readSlot();
  Serial.print(F("Bit #0: ")); Serial.println(bitRead(bufWrite[shift], 0));
  Serial.print(F("Bit #1: ")); Serial.println(bitRead(bufWrite[shift], 1));
  Serial.print(F("Bit #2: ")); Serial.println(bitRead(bufWrite[shift], 2));
  Serial.print(F("Bit #3: ")); Serial.println(bitRead(bufWrite[shift], 3));
  Serial.print(F("Bit #4: ")); Serial.println(bitRead(bufWrite[shift], 4));
  Serial.print(F("Bit #5: ")); Serial.println(bitRead(bufWrite[shift], 5));
  Serial.print(F("Bit #6: ")); Serial.println(bitRead(bufWrite[shift], 6));
  Serial.print(F("Bit #7: ")); Serial.println(bitRead(bufWrite[shift], 7));
}

// Print

void printBuffer(byte* data, byte len) {
  for (size_t i = 0; i < len; i++) {
    if (data[i] < 0x10) {Serial.print('0');}
    Serial.print(data[i], HEX);
    if (i < len - 1) {Serial.print(' ');}
  }
}

// Read

void copyReadToWrite() {
  bufWrite[0] = bufRead[0];
  bufWrite[1] = bufRead[1];
  bufWrite[2] = bufRead[2];
  bufWrite[3] = bufRead[3];
}

byte addr(byte slot) {
  return slot * 4;
}

void readConf() {
  byte retCode = sha204.sha204m_read(bufTx, bufRx, SHA204_ZONE_CONFIG, addr(slot));
  bufRead[0] = bufRx[SHA204_BUFFER_POS_DATA + 0];
  bufRead[1] = bufRx[SHA204_BUFFER_POS_DATA + 1];
  bufRead[2] = bufRx[SHA204_BUFFER_POS_DATA + 2];
  bufRead[3] = bufRx[SHA204_BUFFER_POS_DATA + 3];
  
}

void readSlot() {
  readConf();
  copyReadToWrite();
  
  Serial.print(F("Read: "));
  printBuffer(bufRead, SLOT_LEN);
  Serial.println();
}

// Write

void seti2cAddress(byte b) {
  bufWrite[shift] = b;
}

void writeConfig() {
  byte retCode = sha204.sha204m_execute(SHA204_WRITE,
                                        SHA204_ZONE_CONFIG, slot,
                                        4, bufWrite,
                                        0, NULL,
                                        0, NULL,
                                        WRITE_COUNT_SHORT, bufTx,
                                        WRITE_RSP_SIZE,    bufRx);
}

void loop() {

}

По условию задачи нам нужно получить число (байт), первые 4 бита которого равны единице, а последние — нулю. В шестнадцатеричной форме это число 0x0F (0b00001111), поэтому создаём тестовую переменную testByte, равную 0x0F.

byte testByte = 0x0F;

Производим стандартные (и описанные ранее) действия по чтению и записи слота.

  readSlot();

  seti2cAddress(testByte);
  writeConfig();
  
  readSlot();

и в конце побитово выводим записанный байт на печать в Serial.

  Serial.print(F("Bit #0: ")); Serial.println(bitRead(bufWrite[shift], 0));
  Serial.print(F("Bit #1: ")); Serial.println(bitRead(bufWrite[shift], 1));
  Serial.print(F("Bit #2: ")); Serial.println(bitRead(bufWrite[shift], 2));
  Serial.print(F("Bit #3: ")); Serial.println(bitRead(bufWrite[shift], 3));
  Serial.print(F("Bit #4: ")); Serial.println(bitRead(bufWrite[shift], 4));
  Serial.print(F("Bit #5: ")); Serial.println(bitRead(bufWrite[shift], 5));
  Serial.print(F("Bit #6: ")); Serial.println(bitRead(bufWrite[shift], 6));
  Serial.print(F("Bit #7: ")); Serial.println(bitRead(bufWrite[shift], 7));

Результат работы нашего скетча — на нужную позицию в слоте (конфигурационной зоны) записан байт 0x0F и нужные биты CheckMacConfig выставлены в единицу.

Запись OTP Mode

Байт OTP Mode определяет режим работы OTP зоны памяти микросхемы ATSHA204. Возможны три варианта режима работы этой зоны:

0xAA — Режим только для чтения (по умолчанию). Если OTP зона заблокирована, то запись всех слотов отключена, а чтение разрешено.

0x55 — Режим расхода (уменьшения). Запись в OTP зону, когда она заблокирована, приводит к тому, что биты изменяются только от единицы к нулю. Разрешено чтение всех слотов.

0x00 — Унаследованный режим. Если зона OTP заблокирована, то запись отключена, плюс чтение слотов 0 и 1 и 32-битное чтение отключено.

Скетч записи и изменения байта OTP Mode микросхемы ATSHA204:

/* 
  ATSHA204 Write Config OTP Mode
*/

#include <sha204_library.h>

#define ATSHA204_PIN A3

byte bufTx[SHA204_CMD_SIZE_MAX];
byte bufRx[SHA204_RSP_SIZE_MAX];

byte slot = 4;
byte shift = 2;

byte otpDefault = 0xAA;
byte otpConsump = 0x55;
byte otpLegacy = 0x00;

#define SLOT_LEN 4
byte bufRead[SLOT_LEN];
byte bufWrite[SLOT_LEN];

atsha204Class sha204(ATSHA204_PIN);


void setup() {
  Serial.begin(115200);
  Serial.println(F("ATSHA204 Write Config OTP Mode start..."));

  Serial.print(F("Slot #"));  Serial.println(slot);
  Serial.print(F("Shift #"));  Serial.println(shift);
  
  readSlot();

  setOtpMode(otpConsump);
  writeConfig();
  
  readSlot();
}

// Print

void printBuffer(byte* data, byte len) {
  for (size_t i = 0; i < len; i++) {
    if (data[i] < 0x10) {Serial.print('0');}
    Serial.print(data[i], HEX);
    if (i < len - 1) {Serial.print(' ');}
  }
}

// Read

void copyReadToWrite() {
  bufWrite[0] = bufRead[0];
  bufWrite[1] = bufRead[1];
  bufWrite[2] = bufRead[2];
  bufWrite[3] = bufRead[3];
}

byte addr(byte slot) {
  return slot * 4;
}

void readConf() {
  byte retCode = sha204.sha204m_read(bufTx, bufRx, SHA204_ZONE_CONFIG, addr(slot));
  bufRead[0] = bufRx[SHA204_BUFFER_POS_DATA + 0];
  bufRead[1] = bufRx[SHA204_BUFFER_POS_DATA + 1];
  bufRead[2] = bufRx[SHA204_BUFFER_POS_DATA + 2];
  bufRead[3] = bufRx[SHA204_BUFFER_POS_DATA + 3];
  
}

void readSlot() {
  readConf();
  copyReadToWrite();
  
  Serial.print(F("Read: "));
  printBuffer(bufRead, SLOT_LEN);
  Serial.println();
}

// Write

void setOtpMode(byte b) {
  bufWrite[shift] = b;
}

void writeConfig() {
  byte retCode = sha204.sha204m_execute(SHA204_WRITE,
                                        SHA204_ZONE_CONFIG, slot,
                                        4, bufWrite,
                                        0, NULL,
                                        0, NULL,
                                        WRITE_COUNT_SHORT, bufTx,
                                        WRITE_RSP_SIZE,    bufRx);
}

void loop() {

}

Вначале создаём переменные трёх возможных режимов работы OTP зоны памяти микросхемы ATSHA204 и присваиваем им соответствующие значения, согласно информации из даташита.

byte otpDefault = 0xAA;
byte otpConsump = 0x55;
byte otpLegacy = 0x00;

Затем проводим стандартную операцию по чтению слота памяти, его изменению и последующей записи нового значения байта OTP Mode. Затем читаем и выводим новое состояние слота.

  readSlot();

  setOtpMode(otpConsump);
  writeConfig();
  
  readSlot();

Результат работы нашего скетча:

Режим Default Read-only (0xAA) заменён на Consumption mode (0x55). Таким же образом, использовав переменную otpLegacy вы можете установить режим Legacy mode работы OTP памяти микросхемы ATSHA204.

Запись Selector Mode

Байт Selector Mode отвечает за режим работы селектора (Selector). Сам Selector определяет устройство, которое останется в активном режиме после выполнения команды Pause.

Если байт Selector Mode равен нулю (значение по умолчанию), то селектор может быть обновлён с помощью CreateExtra, любое другое значение запрещают обновление селектора.

Текст скетча записи и изменения байта Selector Mode:

/* 
  ATSHA204 Write Config Selector Mode
*/

#include <sha204_library.h>

#define ATSHA204_PIN A3

byte bufTx[SHA204_CMD_SIZE_MAX];
byte bufRx[SHA204_RSP_SIZE_MAX];

byte slot = 4;
byte shift = 3;

byte selectorUpdated = 0x00;
byte selectorBlocked = 0x55;

#define SLOT_LEN 4
byte bufRead[SLOT_LEN];
byte bufWrite[SLOT_LEN];

atsha204Class sha204(ATSHA204_PIN);


void setup() {
  Serial.begin(115200);
  Serial.println(F("ATSHA204 Write Config Selector Mode start..."));

  Serial.print(F("Slot #"));  Serial.println(slot);
  Serial.print(F("Shift #"));  Serial.println(shift);
  
  readSlot();

  setSelectorMode(selectorBlocked);
  writeConfig();
  
  readSlot();
}

// Print

void printBuffer(byte* data, byte len) {
  for (size_t i = 0; i < len; i++) {
    if (data[i] < 0x10) {Serial.print('0');}
    Serial.print(data[i], HEX);
    if (i < len - 1) {Serial.print(' ');}
  }
}

// Read

void copyReadToWrite() {
  bufWrite[0] = bufRead[0];
  bufWrite[1] = bufRead[1];
  bufWrite[2] = bufRead[2];
  bufWrite[3] = bufRead[3];
}

byte addr(byte slot) {
  return slot * 4;
}

void readConf() {
  byte retCode = sha204.sha204m_read(bufTx, bufRx, SHA204_ZONE_CONFIG, addr(slot));
  bufRead[0] = bufRx[SHA204_BUFFER_POS_DATA + 0];
  bufRead[1] = bufRx[SHA204_BUFFER_POS_DATA + 1];
  bufRead[2] = bufRx[SHA204_BUFFER_POS_DATA + 2];
  bufRead[3] = bufRx[SHA204_BUFFER_POS_DATA + 3];
  
}

void readSlot() {
  readConf();
  copyReadToWrite();
  
  Serial.print(F("Read: "));
  printBuffer(bufRead, SLOT_LEN);
  Serial.println();
}

// Write

void setSelectorMode(byte b) {
  bufWrite[shift] = b;
}

void writeConfig() {
  byte retCode = sha204.sha204m_execute(SHA204_WRITE,
                                        SHA204_ZONE_CONFIG, slot,
                                        4, bufWrite,
                                        0, NULL,
                                        0, NULL,
                                        WRITE_COUNT_SHORT, bufTx,
                                        WRITE_RSP_SIZE,    bufRx);
}

void loop() {

}

Создаём переменные и указываем актуальные значения слота и смещения.

byte slot = 4;
byte shift = 3;

Создаём переменные возможных режимов работы (значение переменной selectorBlocked может быть любым, отличным от нуля).

byte selectorUpdated = 0x00;
byte selectorBlocked = 0x55;

И проводим операцию по чтению слота памяти, его изменению и последующей записи нового значения байта Selector Mode. Затем читаем и выводим новое состояние слота.

  readSlot();

  setSelectorMode(selectorBlocked);
  writeConfig();
  
  readSlot();

Таким образом мы заблокировали возможность обновления Selector при помощи CreateExtra. Если воспользоваться переменной selectorUpdated, то можно вернуть состояние этого байта к значению по умолчанию.

Заключение

В этой статье мы начали знакомство с записью и изменением настроек конфигурационной зоны микросхемы ATSHA204A. В последующих статьях мы продолжим знакомство с этой захватывающей темой и разберём запись и смысл других настроек ATSHA204A.

Ссылки по теме

Работа с SHA-256

ATSHA204 - Обзор

ATSHA204 - Спецификации

ATSHA204 - Библиотека и примеры

ATSHA204A - Чтение зоны конфигурации 1

ATSHA204A - Чтение зоны конфигурации 2

ATSHA204A - Чтение зоны конфигурации 3