Страницы

Ярлыки

ДШИ-200 (1) КСВУ-6 (1) ЛЧМ (1) МДР-23 (1) микроконтроллер (1) перенаправление (1) С (1) структуры (1) учебный курс (1) AC/DC (1) ADC (1) ADS1248 (1) Altium (1) Altuim (1) Amolifer (1) ARM (1) assembler (2) Asynchronous (1) at command (3) at#eaddr (1) at#epassw (1) at#esmtp (1) at#euser (1) at#gprs (1) at#selint=2 (1) at#sgact (1) at#tcpatcmdseq (1) ATX (1) AVR (2) bit (1) boost (1) boot (2) bootlloader (1) C (6) C# (7) C++ (1) CMSIS (1) command (1) CP2101 (1) CSD (1) Danfoss (6) DBGMCU (1) debug (1) debug.ini (1) delegate (1) Discovery (1) DMA (1) DRV8805 (1) DWT (1) e-mail (1) email (1) Exel (1) exFAT (1) FC-051 (1) gl868-dual (2) gl868-dual cmux (1) GPIO (2) GSM (1) I2C (1) IAR (1) ID (1) Invoke (1) Keil (3) LabVIEW (1) Linux (1) LMP7721 (1) LoRa (3) mdmread (1) memory (1) MODBUS (1) Operation Amplifer (1) pack (1) printf (2) printf() (1) RCC (1) retargetting (1) RFM95/96/87/98(W) (1) RS232 (4) RS485 (1) RSAPI.DLL (1) RSS (1) RTC (2) send (2) SerialPort (1) Silabs (1) spl (1) standard peripherals library (1) startup (1) stepper (2) STlink (1) STlink/V2 (2) STM32 (10) stm32 stm32f10x (1) STM32DBG.IN (1) STM32F (19) STM32F103 (4) struct (1) Structure (1) system (1) SystemInit (1) Task (1) telit (5) thread (4) TIM (1) Type Cast (1) UART (1) uni-trend (1) USART (6) USB (1) UT61B (1) viewer (1)

воскресенье, 26 июля 2020 г.

четверг, 5 июля 2018 г.

exFAT - форматируем USB флешку

Расширенная FAT - ExFAT, это файловая система предназначена в основном для сменных флэш-носителях, таких как USB флэш-накопители. Флешки обычно используют либо FAT или FAT32 в качестве файловой системы, но эти файловые системы имеют ряд неприятных ограничений. К примеру - FAT32 имеет максимальный размер файла 4 ГБ, а также ограничивает максимальный размер тома FAT32 до 32 Гб. И как Вы правильно догадываетесь, файловая система FAT имеет еще больше ограничений на размеры файлов так и тома. Компания Microsoft, чтобы преодолеть эти ограничения создала ExFAT.

Основными преимуществами exFAT перед предыдущими версиями FAT:
  • одна из основных причин разработки ExFAT - уменьшение количества перезаписей одного и того же сектора, что само по себе очень важно для флеш-накопителей, у которых ячейки памяти необратимо изнашиваются после определённого количества операций записи.
  • лимит на размер файла 2 в 64 степени байт  - 16 эксабайт.
  • максимальный размер кластера увеличен до 2 в 25 степени байт - 32 мегабайта.
  • улучшено распределение свободного места за счёт введения бит-карты свободного места, что может уменьшать фрагментацию диска.
Но вернёмся к причине написания этой статьи - форматирование в exFAT Вашей флешки. Для этого Вам необходимо использовать команду format (я делал на Windows 7, но предполагаю она будет работать и на vista и на windows server).

Обязательно убедитесь, в имени устройства, которое Вы собираетесь отформатировать !!
Эта операция стирает всю информацию на указывамом Вами устройстве !


В моём случае, флешка определялась как устройство G: 
Запускаете командную строку: ПУСК > Все программы > Стандартные > Коммандная строка
В открывшеся чёрном экранчике вводите
C:>format G: /fs:exfat
Вставьте новый диск в дисковод G:
и нажмите клавишу ENTER...

И если Вы уверены - тогда жмите Enter.

Произойдёт форматирование указанного устройства.
Тип файловой системы: FAT32.
Новая файловая система: EXFAT.
Проверка: 3827 МБ
Метка тома (15 символов, ВВОД - метка не нужна)?

Спросит имя тома, который Вы можете не вводить - просто нажать Enter 
Флэшка готова и отформатирована по файловую систему ExFAT.

суббота, 17 февраля 2018 г.

Boost Regulator

The vast majority of portable devices today feature thin-film transistor (TFT) LCD displays. Such displays need to operate from a low-voltage input supply or a battery source, in the range of +3 to +5 volts. A typical TFT LCD bias supply requires a main supply, also referred to as AV DD (typically in the range of +8 V to +12 V), a positive gate-drive bias (typically in the range of +12 V to +18 V), and a negative gate-drive bias (typically in the range of –5 V to –10 V). Because portable electronics applications demand small size and low profile, the supply must operate at sufficiently high frequency to reduce the size of external filter components. Additionally, a single dc-to-dc controller generating three outputs is highly desirable, because it limits the cost of the solution and minimizes the PCB area required. The circuit shown in the figure below uses a combination boost regulator and charge pump circuitry to accomplish this task.
The circuit employs a single dc-to-dc controller (the A8483, a current-mode–controlled boost regulator) to generate a +8.75 V main supply, capable of delivering up to 50 mA. (Selecting an appropriate feedback voltage divider can change the output voltage.) The 1.2 MHz operating frequency reduces the inductor size and allows operation with tiny ceramic capacitors. Internal compensation simplifies circuit design and reduces external component count. The low-profile (0.75 mm nominal height) MLP/TDFN package allows the boost regulator to be mounted on either side of the PCB to optimize footprint and minimize height. When the internal switch of the A8483 is on, the SW node is near 0 V, with low impedance to circuit ground. When the internal switch of the A8483 switches off in order to provide boost action, the SW node goes up to approximately 9.05 V. This operation allows for an easy implementation of the charge pump with diodes and capacitors, to generate gate-drive supplies at +15 V and -7.5 V with 1 mA output-current capability. The circuit diagram shows optional Zener diodes across gate- driver outputs. These can help to provide good regulation. Additional sequencing features can be added to this solution as needed, by providing pass elements in series with the outputs.



воскресенье, 20 августа 2017 г.

FFC FPC

Circuits  50
Contact Position Bottom
Molex
Part Number: 505110-5091
http://www.molex.com/molex/products/datasheet.jsp?part=active/5051105091_FFC_FPC_CONNECTORS.xml&channel=Products&Lang=en-US#partdetail

Part Number: 505110-5096
http://www.molex.com/molex/products/datasheet.jsp?part=active/5051105096_FFC_FPC_CONNECTORS.xml



================================================================
Circuits  50
Contact Position Bottom
Molex
Part Number: 54132-5033
http://www.molex.com/molex/products/datasheet.jsp?part=active/0541325033_FFC_FPC_CONNECTORS.xml

Part Number: 54132-5062
http://www.molex.com/molex/products/datasheet.jsp?part=active/0541325062_FFC_FPC_CONNECTORS.xml

=================================================================
Circuits  50
Contact Position Bottom
Molex
Part Number: 51296-5033
Part Number: 51296-5094


Circuits  50
Contact Position Bottom
TE connectivity

TE Internal Number: 5-1734592-0

http://www.te.com/usa-en/product-5-1734592-0.html?q=&d=545436%20552704&type=products&samples=N



TE Internal Number: 5-1775333-0
http://www.te.com/usa-en/product-5-1775333-0.html?q=&d=545436%20552704&type=products&samples=N


TE Internal Number: 5-1775635-0
http://www.te.com/usa-en/product-5-1775635-0.html?q=&d=545436%20552704&type=products&samples=N



=================================================================
   =================================================================
Circuits  50
Contact Position Top
Molex

Part Number: 54104-5031 (Au)
http://www.molex.com/molex/products/datasheet.jsp?part=active/0541045031_FFC_FPC_CONNECTORS.xml

Part Number: 54104-5033
http://www.molex.com/molex/products/datasheet.jsp?part=active/0541045033_FFC_FPC_CONNECTORS.xml


Circuits  50
Contact Position Top
TE connectivity

TE Internal Number: 5-1734839-0
http://www.te.com/usa-en/plp/fpc-connectors/Y30oe.html?q=&d=545436%20552706&type=products&samples=N

вторник, 27 июня 2017 г.

Шаговые двигатели Stepper motors

Микросхемы для управления униполярными шаговыми двигателями

Allegro (allegromicro.com)A2544, A2540, SLA7024, SLA7026, SMA7029, SLA7042, SLA7044UCN5804UDN2580, UDN2585, UDN2588, UDN2985, UDN2987, ULN2003, ULN2004, ULN2023, ULN2024, ULN2064, ULN2065, ULN2068, ULN2069, ULN2803, ULN2804, ULN2823, ULN2824
Motorola (motorola.com): MC1413, MC1416
NEC (nec.com): uPA2003, uPA2004
Toshiba (toshiba-components.com): TD62064, TD62164, TD62064A, TD62164B, TD62064B, TD62107, TD62107B, TD62074, TD62074A, TD62318A, TD62308A, TD62318B, TD62308B, TA8415
National Semiconductor (national.com): DS2003, DS3658, DS3668, DS75451, DS75452, DS75453
JRC (njr.com): NJM3517, NJM3545, NJM3548
SANYO (sanyo.com): LB1246
STMicroelectronics (st.com): L702, L6223
Signetics (signetics.com): SAA1027 

Микросхемы для управления биполярными шаговыми двигателями

Allegro (allegromicro.com): A2916, A2917, A2919, A2998, A3948, A3951, A3952, A3953, A3955, A3957, A3958, A3959, A3964, A3966, A3968, A3971, A3972, A3973, A3974, A3976, A3977A6219
Toshiba (toshiba-components.com): TA7289F, TA7289P, TA7774, TA84002, TA8411, TA8430, TA8435, TB62200, TB6500, TB6504, TB6512, TB6526, TB6560
National Semiconductor (national.com): LMD18200, LMD18201, LMD18245
JRC (njr.com): NJM3717, NJM3770, NJM3771, NJM3772, NJM3773, NJM3774, NJM3775, NJM3777, NJU39610, NJU39612
Motorola (motorola.com): MC3479, MC33192, SAA1042
SANYO (sanyo.com): LB11847, LB1651D, LB1656M, LB1657M, LB1839M, LB1840M, LB1845, LB1846M, LB1847, LB1848M, LB1945H, LB1947
STMicroelectronics (st.com): L293, L297L298, L6201, L6202, L6203, L6204, L6205, L6206L6207, L6208L6210, L6219, L6258, L6506, TEA3717, TEA3718
Texas Instruments (ti.com): UC3717, UC3770
NEC (nec.com): uPD16818, uPD16833
Panasonic (panasonic.net): AN6664S, AN6668NS, AN8208SAN8495SB
Rohm Semiconductor (rohm.com): BA6846, BA6343
Samsung (samsung.com): KA2820, KA6202
Fairchild Semiconductor (fairchildsemi.com): KA2820, KA3100
Infineon Technologies AG (infineon.com): TLE4726, TLE4727
Hitachi (hitachi.com): HA13421, HA13475
Mitsubishi (mitsubishielectric.com): M54640P, M54670P, M54679FP
Fujitsu (fujitsu.com): MB86521
ON Semiconductor (onsemi.com): CS279, CS4161, CS8441 

вторник, 30 мая 2017 г.

вторник, 7 февраля 2017 г.

пятница, 9 декабря 2016 г.

I2C oscill for digital POT (potentiometer) MCP454X/456X/464X/466X with STM32F429ZI

DEVADDR=0x5e;  www1=HAL_I2C_Master_Transmit(&hi2c1, (uint16_t) DEVADDR, xBuffer, 2, 10);
DEVADDR=0x5f;  www1=HAL_I2C_Master_Transmit(&hi2c1, (uint16_t) DEVADDR, xBuffer, 2, 10);

суббота, 19 ноября 2016 г.

C++ serial port example

#include "stdafx.h"
#include <windows.h>
#include <iostream>
using namespace std;

typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;

HANDLE hPort; // структура для управления com-port (h_port - адрес)
LPCTSTR sPortName = L"COM7";
DCB dcbSerialParams = { 0 };

void WriteComPort(void);
void ReadComPort(void);


int main()
{
std::cout << "test" << '\n';

WriteComPort();
ReadComPort();

    return 0;
}

void WriteComPort(void) {
char data[] = "Zdorovenki buly";
DWORD dwSize = sizeof(data);
DWORD dwBytesWritten;

hPort = CreateFile(sPortName, GENERIC_READ | GENERIC_WRITE, 0, 0,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);

if (hPort == INVALID_HANDLE_VALUE) {
if (GetLastError() == ERROR_FILE_NOT_FOUND) {
cout << "serial port does not exist \n";
}
else {
cout << "other error \n";
}
}

dcbSerialParams.DCBlength = sizeof(dcbSerialParams);
if (!GetCommState(hPort, &dcbSerialParams)) {
cout << "getting state error\n";
}
dcbSerialParams.BaudRate = CBR_115200;
dcbSerialParams.ByteSize = 8;
dcbSerialParams.StopBits = ONESTOPBIT;
dcbSerialParams.Parity = NOPARITY;

if (!SetCommState(hPort, &dcbSerialParams)) {
cout << "error setting serial port state \n";
}
WriteFile(hPort, data, dwSize, &dwBytesWritten, NULL);
}

void ReadComPort(void) {
DWORD iSize;
char sReceivedChar;
while (1) {
ReadFile(hPort, &sReceivedChar, 1, &iSize, 0);
if (iSize > 0) {
cout << sReceivedChar;
}
}
}

понедельник, 31 октября 2016 г.

Danfoss RS485 setup

8-32 Скорость передачи данных порта ПЧ
9600

8-33 Четность порта ПЧ
[3]               Контроль четности отсутствует (1 стоповый бит)

8-35 Минимальная задержка реакции
0.001 s       Минимальная задержку между получением запроса и передачей ответа

8-36 Максимальная задержка реакции
0.100 s       Максимально допустимая задержку между передачей запроса и получением ответа.                    Превышение времени этой задержки приводит к тайм-ауту командного слова.


вторник, 6 сентября 2016 г.

суббота, 3 сентября 2016 г.

MODBUS

Описание протокола Modbus RTU

Modbus —коммуникационный протокол, основан на архитектуре ведущий-ведомый (master-slave). Использует для передачи данных интерфейсы RS-485, RS-422, RS-232, а также Ethernet сети TCP/IP (протокол Modbus TCP).
Сообщение Modbus RTU состоит из адреса устройства SlaveID, кода функции, специальных данных в зависимости от кода функции и CRC контрольной суммы.
SlaveIDКод функцииСпециальные данныеCRC
Если отбросить SlaveID адрес и CRC контрольную сумму, то получится PDU, Protocol Data Unit.
SlaveID – это адрес устройства, может принимать значение от 0 до 247, адреса с 248 до 255 зарезервированы.
Данные в модуле хранятся в 4 таблицах.
Две таблицы доступны только для чтения и две для чтения-записи.
В каждой таблице помещается 9999 значений.
Номер регистраАдрес регистра HEXТипНазваниеТип
1-99990000 до 270EЧтение-записьDiscrete Output CoilsDO
10001-199990000 до 270EЧтениеDiscrete Input ContactsDI
30001-399990000 до 270EЧтениеAnalog Input RegistersAI
40001-499990000 до 270EЧтение-записьAnalog Output Holding RegistersAO
В сообщении Modbus используется адрес регистра.
Например, первый регистр AO Holding Register, имеет номер 40001, но его адрес равен 0000.
Разница между этими двумя величинами есть смещение offset.
Каждая таблица имеет свое смещение, соответственно: 1, 10001, 30001 и 40001.


пятница, 2 сентября 2016 г.

Danfoss MODBUS control

(0x02) — чтение значений из нескольких дискретных входов (Read Discrete Inputs).
(0x03) — чтение значений из нескольких регистров хранения (Read Holding Registers).
(0x04) — чтение значений из нескольких регистров ввода (Read Input Registers).
(0x05) — запись значения одного флага (Force Single Coil).
(0x06) — запись значения в один регистр хранения (Preset Single Register).
(0x07) — Чтение сигналов состояния (Read Exception Status)
(0x0F) — запись значений в несколько регистров флагов (Force Multiple Coils)
(0x10) — запись значений в несколько регистров хранения (Preset Multiple Registers)
(0x16) — запись в один регистр хранения с использованием маски «И» и маски «ИЛИ» (Mask Write Register).
(0x18) — Чтение данных из очереди (Read FIFO Queue)
(0x14) — Чтение из файла (Read File Record)
(0x15) — Запись в файл (Write File Record)
(0x08) — Диагностика (Diagnostic)
(0x0B) — Чтение счетчика событий (Get Com Event Counter)
(0x0C) — Чтение журнала событий (Get Com Event Log)
(0x11) — Чтение информации об устройстве (Report Slave ID)
(0x2B) — Encapsulated Interface Transport

C34F  -  047C    start
C34F  -  042C    stop

C359  -   20 00   set frequency  25,6 Hz



Danfoss MODBUS CRC16 calculate

uint16_t crc16(uint8_t *adr_buffer, uint32_t byte_cnt)
{
    static unsigned char auchCRCHi[]=
    {
        0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
        0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
        0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
        0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
        0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
        0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
        0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
        0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
        0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
        0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
        0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
        0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
        0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
        0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
        0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
        0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
    };
    /*Table of CRC values for low–order byte*/
    static char auchCRCLo[]=
    {
        0x00,0xC0,0xC1,0x01,0xC3,0x03,0x02,0xC2,0xC6,0x06,0x07,0xC7,0x05,0xC5,0xC4,0x04,
        0xCC,0x0C,0x0D,0xCD,0x0F,0xCF,0xCE,0x0E,0x0A,0xCA,0xCB,0x0B,0xC9,0x09,0x08,0xC8,
        0xD8,0x18,0x19,0xD9,0x1B,0xDB,0xDA,0x1A,0x1E,0xDE,0xDF,0x1F,0xDD,0x1D,0x1C,0xDC,
        0x14,0xD4,0xD5,0x15,0xD7,0x17,0x16,0xD6,0xD2,0x12,0x13,0xD3,0x11,0xD1,0xD0,0x10,
        0xF0,0x30,0x31,0xF1,0x33,0xF3,0xF2,0x32,0x36,0xF6,0xF7,0x37,0xF5,0x35,0x34,0xF4,
        0x3C,0xFC,0xFD,0x3D,0xFF,0x3F,0x3E,0xFE,0xFA,0x3A,0x3B,0xFB,0x39,0xF9,0xF8,0x38,
        0x28,0xE8,0xE9,0x29,0xEB,0x2B,0x2A,0xEA,0xEE,0x2E,0x2F,0xEF,0x2D,0xED,0xEC,0x2C,
        0xE4,0x24,0x25,0xE5,0x27,0xE7,0xE6,0x26,0x22,0xE2,0xE3,0x23,0xE1,0x21,0x20,0xE0,
        0xA0,0x60,0x61,0xA1,0x63,0xA3,0xA2,0x62,0x66,0xA6,0xA7,0x67,0xA5,0x65,0x64,0xA4,
        0x6C,0xAC,0xAD,0x6D,0xAF,0x6F,0x6E,0xAE,0xAA,0x6A,0x6B,0xAB,0x69,0xA9,0xA8,0x68,
        0x78,0xB8,0xB9,0x79,0xBB,0x7B,0x7A,0xBA,0xBE,0x7E,0x7F,0xBF,0x7D,0xBD,0xBC,0x7C,
        0xB4,0x74,0x75,0xB5,0x77,0xB7,0xB6,0x76,0x72,0xB2,0xB3,0x73,0xB1,0x71,0x70,0xB0,
        0x50,0x90,0x91,0x51,0x93,0x53,0x52,0x92,0x96,0x56,0x57,0x97,0x55,0x95,0x94,0x54,
        0x9C,0x5C,0x5D,0x9D,0x5F,0x9F,0x9E,0x5E,0x5A,0x9A,0x9B,0x5B,0x99,0x59,0x58,0x98,
        0x88,0x48,0x49,0x89,0x4B,0x8B,0x8A,0x4A,0x4E,0x8E,0x8F,0x4F,0x8D,0x4D,0x4C,0x8C,
        0x44,0x84,0x85,0x45,0x87,0x47,0x46,0x86,0x82,0x42,0x43,0x83,0x41,0x81,0x80,0x40,
    };

    unsigned char uchCRCHi = 0xFF;
    unsigned char uchCRCLo = 0xFF;
    unsigned uIndex;
 
    /* CRC Generation Function */
    while( byte_cnt--) /* pass through message buffer */
    {
        uIndex = uchCRCHi ^ *adr_buffer++; /* calculate the CRC */
        uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex];
        uchCRCLo = auchCRCLo[uIndex];
    }
return (uchCRCHi << 8 | uchCRCLo);
}

Danfoss VLT Micro Drive FC-051 MODBUS protocol

CRC Generation

A procedure for generating a CRC is:

1, Load a 16–bit register with FFFF hex (all 1’s). Call this the CRC register.
2. Exclusive OR the first 8–bit byte of the message with the low–order byte of the 16–bit CRC register, putting the result in the CRC register.
3. Shift the CRC register one bit to the right (toward the LSB), zero–filling the MSB. Extract and examine the LSB.
4. (If the LSB was 0): Repeat Step 3 (another shift). (If the LSB was 1): Exclusive OR the CRC register with the polynomial value A001 hex (1010 0000 0000 0001).
5. Repeat Steps 3 and 4 until 8 shifts have been performed. When this is done, a complete 8–bit byte will have been processed.
6. Repeat Steps 2 through 5 for the next 8–bit byte of the message. Continue doing this until all bytes have been processed.
7. The final contents of the CRC register is the CRC value.
8. When the CRC is placed into the message, its upper and lower bytes must be swapped as described below.

Placing the CRC into the Message

When the 16–bit CRC (two 8–bit bytes) is transmitted in the message, the low-order byte will be transmitted first, followed by the high-order byte. For example, if the CRC value is 1241 hex (0001 0010 0100 0001):

Example 

An example of a C language function performing CRC generation is shown on the following pages. All of the possible CRC values are preloaded into two arrays, which are simply indexed as the function increments through the message buffer. One array contains all of the 256 possible CRC values for the high byte of the 16–bit CRC field, and the other array contains all of the values for the low byte. Indexing the CRC in this way provides faster execution than would be achieved by calculating a new CRC value with each new character from the message buffer.

Note

This function performs the swapping of the high/low CRC bytes internally. The bytes are already swapped in the CRC value that is returned from the function. Therefore the CRC value returned from the function can be directly placed into the message for transmission.

The function takes two arguments:
unsigned char *puchMsg ; A pointer to the message buffer containing binary data to be used for generating the CRC
unsigned short usDataLen ; The quantity of bytes in the message buffer. The function returns the CRC as a type unsigned short.

CRC Generation Function

unsigned short CRC16(puchMsg, usDataLen)
unsigned char *puchMsg ; /* message to calculate CRC upon */
unsigned short usDataLen ; /* quantity of bytes in message */
{
unsigned char uchCRCHi = 0xFF ; /* high byte of CRC initialized */
unsigned char uchCRCLo = 0xFF ; /* low byte of CRC initialized */
unsigned uIndex ; /* will index into CRC lookup table */
while (usDataLen––) /* pass through message buffer */
{
uIndex = uchCRCHi ^ *puchMsgg++ ; /* calculate the CRC */
uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex} ;
uchCRCLo = auchCRCLo[uIndex] ;
}
return (uchCRCHi << 8 | uchCRCLo) ;
}


High-Order Byte Table
/* Table of CRC values for high–order byte */
static unsigned char auchCRCHi[] = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40
} ;
Low-Order Byte Table
/* Table of CRC values for low–order byte */
static char auchCRCLo[] = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
0x40
} ;


четверг, 1 сентября 2016 г.

Danfoss VLT Micro Drive FC-051 FC protocol

FC-протокол, также называемый шиной FC или стандартной шиной, является стандартной периферийной шиной приводов Danfoss. Физическим уровнем является RS485, т.е. используется порт RS485, встроенный в устройство преобразователь частоты. FC-протокол поддерживает разные форматы телеграммы.
- укороченный формат из 8 байт для технологических данных (process data)
- удлиненный формат из 16 байт, который также включает канал параметров (parameter channel).
- формат, используемый для текстов.

FC-протокол обеспечивает доступ к командному слову (Control Word) и заданию по шине (Bus Reference) преобразователя частоты.

Командное слово (Control Word) позволяет главному устройству управлять несколькими важными функциями преобразователя частоты.

Запуск (Start)
Останов преобразователь частоты различными способами (Stop of the frequency converter in various ways):
     - Останов выбегом (Coast stop)
     - Быстрый останов (Quick stop)
     - Останов торможением постоянным током (DC Brake stop)
     - Нормальный останов (изменением скорости) (Normal (ramp) stop)
Возврат в исходное состояние (сброс) после аварийного отключения (Reset after a fault trip)
Работа с различными предустановленными скоростями  (Run at various preset speeds)
Работа в обратном направлении (Run in reverse)
Изменение активного набора параметров (Change of the active set-up)
Управление 2 реле, встроенными в преобразователь частоты (Control of the 2 relays built into the frequency converter)

понедельник, 4 июля 2016 г.

C# лямбда-выражения

Лямбда-выражения предназначены для определения анонимных методов в сжатой манере, тем самым еще больше упрощая работу с делегатами.


Делегаты, анонимные методы и лямбда-выражения
В качестве примера рассмотрим простой код, где нам надо получить сумму или разницу 2 целых чисел стандартным образом:
using System;
namespace SimpleLambda
{
  class Program
  {
    static void Main(string[] args)
    {
      //Стандартный способ
      Console.WriteLine("5 + 3 = {0}", Sum(5, 3));
      Console.WriteLine("5 - 3 = {0}", Sub(5, 3));

      Console.ReadLine();
    }

    //Сумма двух чисел
    public static int Sum(int x, int y)
    {
      return x + y;
    }

    //Разница двух чисел
    public static int Sub(int x, int y)
    {
      return x - y;
    }
  }
}
Результат вывода в консоль:
5 + 3 = 8
5 - 3 = 2


C# Thread 2

using System.Threading;

Запустим внутри функции fnbig поток fnsmall

public void fnbig()
{
    //код до запуска потока
    Thread potok1 = new Thread(fnsmall_1); // создание отдельного потока
    potok1.Start(); // запуск потока
    // код после запуска первого потока
    Thread potok2 = new Thread(fnsmall_2); // создание отдельного потока
    potok2.Start();
    // десь код после запуска второго потока
}

public void fnsmall_1
{
//тело функции, выполняющейся в отдельном потоке
}

public void fnsmall_2
{
//тело функции, выполняющейся в отдельном потоке
}

После выход из fnbig потоки продолжают свою работу пока до вызываемого ими кода. Есть способ, который позволяет при завершении главной функции, которая запустила потоки, сразу завершать и выполнение потоков, для этого добавляем потоку параметр «IsBackground = true»:

public void fnbig()
{
    //  код до запуска потока
    Thread potok1 = new Thread(fnsmall_1); // создание отдельного потока
    potok1.IsBackground = true;
// завершить поток при завершении основного потока (объявлять, если точно знаете, что вам это нужно, иначе поток завершится не выполнив свою работу до конца)
    potok1.Start(); // запуск потока
    // код после запуска первого потока
}

Теперь у нас поток будет завершён сразу после выполнения fnbig().
Если вы хотите узнать в каком состоянии сейчас находится запущенный поток, то вам необходимо получить его статус «potok1.ThreadState». Подробное описание статусов можете просмотреть на сайте  MSDN .



воскресенье, 3 июля 2016 г.

LabVIEW Type Cast conversion

Type Cast Function (Data Manipulation Functions)

Casts x to the data type, type, by flattening it and unflattening it using the new data type. If the function must reinterpret data instead of transforming it, LabVIEW uses a temporary buffer.

type is the data type to which you want to convert the data. Wire any constant or control to type to set the data type to which you want to convert the data. LabVIEW ignores any data in the constant or control you wire to type.

x is the data you want to convert to type. x can be any data type.

*(type *) &x is the value provided in x and converted to the same data type as type.

Type Cast (приведение типа) дает возможность изменить дескриптор типа данных без
модификации самих данных. Данные не преобразуются, меняется только их дескриптор.
Можно взять любой тип данных (строковые, логические, числовые, кластеры и массивы) и 
обозначить его как нибудь иначе.  Функция преобразует данные на входе х к типу данных,
заденному на входе type. Вход type только "шаблоном" для определения типа, в который
будет преобразован вход х , поэтому его реальное значение игнорируется, учитывается только
его тип (дескриптор данных).
Например, возьмем строку в ASCII в качестве входного параметра, в качестве type возьмем число в формате U32, выход функции подключим к  функции преобразования  Number To Hexadecimal String и к числовому индикатору индикатору в HEX формате, получим следующее:
type U32

 или в более упрощенном виде:
type U32


Пример преобразования числа в HEX-формате в строку ASCII:

type string

пятница, 1 июля 2016 г.

ADC to UART convertion with STM32F030

Structure for command of control ADC start & setting  is sting with 6 byte

1 -  set/reset  autostart for ADC conversion ( 1 - single start ADC, other - autostart)

2 - HI byte for delay (msec) ADC start (hex mode)
3 - LO byte for delay(msec) ADC  start (hex mode)

4 - HI byte for ADC sample number  (hex mode)
5 - LO byte for ADC sample number  (hex mode)

6 - 0xFF - end byte


Structure for ADC send result of measurement

1 - HI digit of ADC result in ASCII format (0x30...0x39)
1 - MI digit of ADC result in ASCII format (0x30...0x39)
1 - MI digit of ADC result in ASCII format (0x30...0x39)
1 - LO digit of ADC result in ASCII format (0x30...0x39)
5 - 0x0D
6 - 0x0A










Keil code for main.c

среда, 29 июня 2016 г.

Unipolar stepper control DRV8805 with STM32F103 (for МДР-23)










Structure for command of control of stepper motor with 8 byte

1 -  0x01 start byte 

2 - 0x01 forward rotation, else other - rewind rotation

3 - 0x00 reserv

4 - HI byte for number of steps (hex mode)  
5 - MI byte for number of steps (hex mode)   
6 - MI byte for number of steps (hex mode)  
7 - LO byte for number of steps (hex mode)  

8 - 0xFF - end byte


Send from stepper motor to PC for control

TxData[0] = 0x30;
TxData[1] = 0x31;
TxData[2] = 0x32;
TxData[3] = 0x33;
TxData[4] = 0x34;
TxData[5] = 0x35;
TxData[6] = 0x0D;
TxData[7] = 0x0A;

понедельник, 27 июня 2016 г.

C# Thread

https://msdn.microsoft.com/ru-ru/library/ts553s52(v=vs.110).aspx

https://msdn.microsoft.com/ru-ru/library/1h2f2459.aspx

BackgroundWorker позволяет вызывать некоторую операцию в отдельном потоке.

Объявляем сам объект и инициализируем его свойства:

backgroundWorker.WorkerReportsProgress = true;
backgroundWorker.WorkerSupportsCancellation = true;
backgroundWorker.DoWork += new System.ComponentModel.DoWorkEventHandler(this.backgroundWorker_DoWork);
backgroundWorker.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorker_RunWorkerСompleted);
backgroundWorker.ProgressChanged += new System.ComponentModel.ProgressChangedEventHandler(this.backgroundWorker_ProgressChanged;

DoWork - это что у нас будет делать фоновый поток, для примера просто будем вызывать Sleep у текущего (фонового) потока

void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
       for (int i = 1; i &lt;= 100; i++)
       {
            if (backgroundWorker.CancellationPending)
                return;
            Thread.Sleep(1000);
            backgroundWorker.ReportProgress(i);
       }
}