diff --git a/schema.graphql b/schema.graphql
index a1aa85b..515dbef 100644
--- a/schema.graphql
+++ b/schema.graphql
@@ -606,6 +606,8 @@ input create_global_input {
   email: String
   github: String
   id: ID
+  ntfy_password: String
+  ntfy_user: String
   recent_articles_limit: Int
   telegram: String
   title: String
@@ -648,6 +650,8 @@ input create_project_input {
 }
 
 input create_project_translations_input {
+  article_url: String
+  demo_url: String
   description: String
   icon: create_directus_files_input
   id: ID
@@ -655,7 +659,7 @@ input create_project_translations_input {
   project_id: create_project_input
   source_url: String
   title: String
-  year: String
+  year: Int
 }
 
 input create_tag_input {
@@ -1662,6 +1666,8 @@ type global {
   email: String
   github: String
   id: ID!
+  ntfy_password: String
+  ntfy_user: String
   recent_articles_limit: Int
   telegram: String
   title: String
@@ -1676,6 +1682,8 @@ input global_filter {
   email: string_filter_operators
   github: string_filter_operators
   id: number_filter_operators
+  ntfy_password: string_filter_operators
+  ntfy_user: string_filter_operators
   recent_articles_limit: number_filter_operators
   telegram: string_filter_operators
   title: string_filter_operators
@@ -1965,6 +1973,8 @@ type project_mutated {
 }
 
 type project_translations {
+  article_url: String
+  demo_url: String
   description: String
   icon(filter: directus_files_filter, limit: Int, offset: Int, page: Int, search: String, sort: [String]): directus_files
   id: ID!
@@ -1972,7 +1982,7 @@ type project_translations {
   project_id(filter: project_filter, limit: Int, offset: Int, page: Int, search: String, sort: [String]): project
   source_url: String
   title: String
-  year: String
+  year: Int
 }
 
 type project_translations_aggregated {
@@ -1989,6 +1999,8 @@ type project_translations_aggregated {
 }
 
 type project_translations_aggregated_count {
+  article_url: Int
+  demo_url: Int
   description: Int
   """SVG"""
   icon: Int
@@ -2003,11 +2015,14 @@ type project_translations_aggregated_count {
 type project_translations_aggregated_fields {
   id: Float
   project_id: Float
+  year: Float
 }
 
 input project_translations_filter {
   _and: [project_translations_filter]
   _or: [project_translations_filter]
+  article_url: string_filter_operators
+  demo_url: string_filter_operators
   description: string_filter_operators
   icon: directus_files_filter
   id: number_filter_operators
@@ -2015,7 +2030,7 @@ input project_translations_filter {
   project_id: project_filter
   source_url: string_filter_operators
   title: string_filter_operators
-  year: string_filter_operators
+  year: number_filter_operators
 }
 
 type project_translations_mutated {
@@ -2029,6 +2044,8 @@ input project_translations_quantifier_filter {
   _none: project_translations_filter
   _or: [project_translations_filter]
   _some: project_translations_filter
+  article_url: string_filter_operators
+  demo_url: string_filter_operators
   description: string_filter_operators
   icon: directus_files_filter
   id: number_filter_operators
@@ -2036,7 +2053,7 @@ input project_translations_quantifier_filter {
   project_id: project_filter
   source_url: string_filter_operators
   title: string_filter_operators
-  year: string_filter_operators
+  year: number_filter_operators
 }
 
 input string_filter_operators {
@@ -2249,6 +2266,8 @@ input update_global_input {
   email: String
   github: String
   id: ID
+  ntfy_password: String
+  ntfy_user: String
   recent_articles_limit: Int
   telegram: String
   title: String
@@ -2291,6 +2310,8 @@ input update_project_input {
 }
 
 input update_project_translations_input {
+  article_url: String
+  demo_url: String
   description: String
   icon: update_directus_files_input
   id: ID
@@ -2298,7 +2319,7 @@ input update_project_translations_input {
   project_id: update_project_input
   source_url: String
   title: String
-  year: String
+  year: Int
 }
 
 input update_tag_input {
@@ -2343,6 +2364,8 @@ type version_global {
   email: String
   github: String
   id: ID
+  ntfy_password: String
+  ntfy_user: String
   recent_articles_limit: Int
   telegram: String
   title: String
@@ -2385,6 +2408,8 @@ type version_project {
 }
 
 type version_project_translations {
+  article_url: String
+  demo_url: String
   description: String
   icon: JSON
   id: ID
@@ -2392,7 +2417,7 @@ type version_project_translations {
   project_id: JSON
   source_url: String
   title: String
-  year: String
+  year: Int
 }
 
 type version_tag {
diff --git a/src/components/ProjectItem.astro b/src/components/ProjectItem.astro
index e3c7e9e..6adc49e 100644
--- a/src/components/ProjectItem.astro
+++ b/src/components/ProjectItem.astro
@@ -1,55 +1,56 @@
 ---
 import { Icon } from "astro-icon/components";
-import type { CollectionEntry } from "astro:content";
 import UIString from "@components/UIString.astro";
+import { Project_TranslationsQuery } from "../graphql/graphql";
+import { DIRECTUS_URL } from "astro:env/server";
 
 export interface Props {
-	data: CollectionEntry<"projects">["data"];
+	data: Project_TranslationsQuery["project_translations"][0];
 }
 
 const { data } = Astro.props as Props;
-const { icon, title, year, description, articleUrl, sourceUrl, demoUrl } = data;
+const { icon, title, year, description, article_url, source_url, demo_url } = data;
 ---
 
-<div class='project-item'>
-	<div class='project-item__heading'>
+<div class="project-item">
+	<div class="project-item__heading">
 		<h2>
-			<Icon name={icon} width='20' height='20' />
+			{icon && <img data-icon src={`${DIRECTUS_URL}/assets/${icon.filename_disk}`} />}
 			{title}
 		</h2>
 		<span>{year}</span>
 	</div>
-	<div class='project-item__description'>
+	<div class="project-item__description">
 		<p>{description}</p>
 	</div>
-	<div class='project-item__links'>
+	<div class="project-item__links">
 		{
-			articleUrl && (
-				<a class='btn-link' href={articleUrl} target='_blank'>
+			article_url && (
+				<a class="btn-link" href={article_url} target="_blank">
 					<UIString key={"btn.article"} />
 				</a>
 			)
 		}
 		{
-			sourceUrl && (
-				<a class='btn-link' href={sourceUrl} target='_blank'>
+			source_url && (
+				<a class="btn-link" href={source_url} target="_blank">
 					<UIString key={"btn.sourceCode"} />
-					<Icon name='mdi:link-variant' width='15' height='15' />
+					<Icon name="mdi:link-variant" width="15" height="15" />
 				</a>
 			)
 		}
 		{
-			demoUrl && (
-				<a class='btn-link' href={demoUrl} target='_blank'>
+			demo_url && (
+				<a class="btn-link" href={demo_url} target="_blank">
 					<UIString key={"btn.demo"} />
-					<Icon name='mdi:link-variant' width='15' height='15' />
+					<Icon name="mdi:link-variant" width="15" height="15" />
 				</a>
 			)
 		}
 	</div>
 </div>
 
-<style lang='scss'>
+<style lang="scss">
 	.project-item {
 		display: flex;
 		flex-direction: column;
diff --git a/src/content/authors/en/сергей-ярков.md b/src/content/authors/en/сергей-ярков.md
deleted file mode 100644
index ecc73c2..0000000
--- a/src/content/authors/en/сергей-ярков.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-firstName: Sergey
-lastName: Yarkov
----
-My name is Sergey and I am a web developer. My main activity is creating web sites. I am interested in areas such as programming, embedded systems, and electronics.
-I started making web sites in 2017, starting with simple HTML pages, and in 2019 I started learning programming. At present, I have experience in **full-stack** web development of client-server applications that solve a wide range of tasks.
-Some of my personal [projects](/projects/) I put in public access on [Github](https://github.com/sergeyyarkov).
-
-## Purpose of this site
-
-I originally created this website for myself, to consolidate my knowledge by writing articles. 
-Since 2022, I have been posting materials on this website, and now at any time I can return to any topic and learn it again.
-My articles can also help someone with mastering a particular topic. The main direction of this site is IT, 
-and [here](/articles/) I publish materials on topics that interest me, as well as talk about my [projects](/projects/). 
-I am absolutely calm about any criticism and I do not claim to be the best programmer in the world, 
-so do not judge the materials of this resource harshly.
-
-## Skills
-
-This list shows the skills and technologies that I have used/use in my projects.
-For creating web projects, I use **Node.js** and the **Adonis.js** framework for the server-side.
-For the client-side, I develop using **React.js** or **Alpine.js**.
-
-<q>this website is made using the [**Astro.js**](https://astro.build) framework and [**Solid.js**](https://www.solidjs.com/) library.</q>
\ No newline at end of file
diff --git a/src/content/authors/ru/сергей-ярков.md b/src/content/authors/ru/сергей-ярков.md
deleted file mode 100644
index a6d833d..0000000
--- a/src/content/authors/ru/сергей-ярков.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-firstName: Сергей
-lastName: Ярков
----
-Я являюсь веб-разработчиком с опытом создания веб-сайтов с 2017 года. Специализируюсь на **full-stack** веб-разработке клиент-серверных приложений, решающих разнообразные задачи. Мне интересны такие сферы как программирование, встраиваемые системы и электроника. Начал с верстки простых HTML страниц и с 2019 года углубленно занимаюсь программированием. На сегодняшний день имею опыт разработки сложных приложений и публикую некоторые [проекты ](https://yarkov.tech/projects/)в открытый доступ на [GitHub](https://github.com/sergeyyarkov).
-
-## О ресурсе
-
-Изначально этот сайт был создан для личного использования, чтобы систематизировать и закреплять свои знания через написание статей. С 2022 года я начал публиковать материалы на этом сайте, и теперь в любой момент могу вернуться к любой теме для её повторного изучения. Я надеюсь, что мои статьи окажутся полезными и для других, помогая освоить различные темы.
-
-Основное направление сайта — информационные технологии. В разделе [статей ](https://yarkov.tech/articles/)я делюсь материалами на интересующие меня темы, а также рассказываю о своих [проектах](https://yarkov.tech/projects/).
-
-## Навыки
-
-**Проектирование баз данных 📊**: Умею проектировать ERD (диаграммы сущностей и связей) базы данны.
-
-**Деплой приложений 🚀**: Опыт деплоя приложений с использованием Docker и базовых инструментов CI/CD.
-
-**Веб-Разработка 🌐**: Использую Node.js для разработки веб-приложений и веб-сайтов с использованием таких технологий как Directus, Astro.js, Adonis.js, Express.js, Alpine.js, Vite.js, TailwindCSS, SASS.
-
-**Серверы 🖥️**: Умею работать с Linux и настраивать веб-сервер Nginx.
-
-**Интерфейсы 🎨**: Имею опыт работы в Figma и могу составлять пользовательские интерфейсы (есть базовое понимание веб-дизайна).
-
-**Управление базами данных 🗄️**: Умею использовать и настраивать PostgreSQL, MongoDB и Redis (реляционные и нереляционные базы данных).
-
-**Отладка и оптимизация кода 🐞**: Опыт отладки кода,поиска ошибок и проведения рефакторинга с целью оптимизации.
-
-**Архитектура** 🏛️: Понимание принципов работы микросервисной и монолитной архитектуры приложения.
-
-**GIT** 🔧: Я использую Gitflow для контроля версий веб-проектов и Git Submodules. [Пример ](https://github.com/sergeyyarkov/educt/tree/main)организации проекта
-
-**Встраиваемые системы 🔌**: Умею программировать микроконтроллеры AVR и разрабатывать электронные устройства, включая разработку схемотехники и трассировку печатных плат в KiCAD.
-
-**Сборка проектов на C 🛠️**: Имею базовые знания сборки проектов на C с использованием Makefile.
-
-Ниже представлен более подробный список того что я использую.
-
-_этот веб-сайт сделан с помощью фреймворка **[Astro.js](https://astro.build)** и библиотеки **[Solid.js](https://www.solidjs.com/)**_
diff --git a/src/content/blog/en/использование-webserial-api-для-общения-с-микроконтроллером.md b/src/content/blog/en/использование-webserial-api-для-общения-с-микроконтроллером.md
deleted file mode 100644
index 54c58eb..0000000
--- a/src/content/blog/en/использование-webserial-api-для-общения-с-микроконтроллером.md
+++ /dev/null
@@ -1,898 +0,0 @@
----
-coverImage: /media/serial-port.jpg
-draft: false
-author: Sergey Yarkov
-title: Using the WebSerial API to communicate with the microcontroller
-description: We will talk about what is WebSerial API, how it can be used in a
-  browser to read and write data to a serial device and where it can be applied.
-tags:
-  - JavaScript
-  - AVR
-  - WebSerial API
-  - Tutorial
-pubDate: 2022-11-04T21:00:00.000Z
-updatedDate: 2023-02-13T16:34:23.326Z
----
-# What you will learn
-
-By the end you will learn how to send and receive data from a serial port device in a browser, develop a demo web application that sends commands to a serial port microcontroller and write firmware for the [AVR128DA48](http://ww1.microchip.com/downloads/en/DeviceDoc/40002183A.pdf) microcontroller to process those commands. You can see the finished version of the project [here](https://web-serial-example.netlify.app/), the sources are uploaded to [repository](https://github.com/sergeyyarkov/avr128da48_web-serial-example) on GitHub.
-
-# What it is and where it's used
-
-The WebSerial API is a browser-based API that provides the ability to read and write data to a serial device. Using this API is quite easy, you only need to write a few lines of code to receive or send your data. There is also a detailed [documentation](https://wicg.github.io/serial/) with examples of how to use this API.
-
-Thanks to this API, new possibilities open up. For example you can flash your microcontroller right from the browser which sounds really interesting (but you need to write a bootloader) or you can just output the sensor info to a web page. The possibilities are endless, it all depends on your imagination.
-
-There are also high level APIs to access devices like a gamepad or camera. I'll leave this link to [this](https://web.dev/devices-introduction/) article which talks about a list of these APIs.
-
-# Browser support.
-
-As of this writing (2022), full support for this API is only available in Chromium-based browsers. You can see the full table at [Can I Use](https://caniuse.com/web-serial).
-
-On Android, support can be provided based on [WebUSB API](https://wicg.github.io/webusb/) and [Serial API polyfill](https://github.com/google/web-serial-polyfill).
-
-# A short excursus about UART
-
-Before you work with serial port it would be nice to know the basics of UART data transfer protocol, if you are already familiar with it you can skip this part.
-
-**UART** stands for Universal Asynchronous Receiver Transmitter and defines a protocol for sending and receiving data between two devices. **Universal** means that we can customize the parameters, including the baud rate. **Asynchronous**, on the other hand, means we have no synchronizing signal between transmitter and receiver. There is also a synchronous version of data transmission with a common clock signal, which can transmit data much faster, but it is rarely used. Only two lines are used to communicate between the two devices and these are designated as RX (**receiver**) and TX (**transmitter**).
-
-<figure>
-
-<img alt="Wiring diagram of two UART devices" width="550" height="300" src="/media/uart-connection.jpg" loading="lazy" decoding="async">
-
-<figcaption>Wiring diagram of two UART devices</figcaption>
-
-</figure>
-
-UART transmits data one bit at a time in one of three modes:
-
-* one-way mode - data is sent in one direction only, from transmitter to receiver
-* half-duplex mode - devices can transmit and receive data one at a time
-* full-duplex mode - devices can transmit and receive data simultaneously.
-
-Since this project is supposed to use asynchronous version of the UART, then accordingly you need to set **the same**bit rate per second (`baud rate`, `bps`) on the two devices. The most common bit rates are: **4800, 9600, 19.2K, 57.6K, and 115.2K.**
-
-Data is transmitted in so-called `packets`, where each packet contains:
-
-* start bit and stop bit - the start bit signals the arrival of data bits, the stop bit signals the end of the data, respectively.
-* data bits - user data that comes right after the start bit, it can contain from 5 to 8 bits.
-* the parity bit is an optional bit that comes after the data bits and before the stop bit and is used to detect errors.
-
-<figure>
-	<img src="/media/uart-packet.jpg" width="700" height="300" alt="Structure of the UART packet" format="webp">
-	<figcaption>Structure of the UART packet</figcaption>
-</figure>
-
-I think this information is enough to understand what UART is all about. If you want to learn more about this interface there are many articles about it on the internet.
-
-# Interface Converter
-
-Since you will most likely connect the microcontroller to the USB port of your computer, you need some kind of converter between the two interfaces to send and receive data, since USB and UART are completely different data transfer protocols. There are many such translators available, here are some of them: [CH340](https://pdf1.alldatasheet.com/datasheet-pdf/view/1132602/WCH/CH340.html), [CP2102](https://pdf1.alldatasheet.com/datasheet-pdf/view/201067/SILABS/CP2102.html) or [FT232](https://pdf1.alldatasheet.com/datasheet-pdf/view/197629/FTDI/FT232BL.html). If you are using an Arduino UNO debug board then you already have one of these converters on your board.
-
-<figure>
-<img src="/media/arduino-uart-converter.png" width="470" height="320" alt="CH340G interface converter on Arduino UNO board" format="webp"><figcaption>
- CH340G interface converter on Arduino UNO board
- </figcaption>
-</figure>
-
-If you don't have this interface converter on your development board, you can buy it in any store and it usually costs less than $5.
-
-# Microcontroller firmware development
-
-As I mentioned before the firmware will be written for the AVR128DA48 Microcontroller. It doesn't really matter what kind of microcontroller you use, you just need to be able to send and receive data using the UART peripherals on your microcontroller.
-
-The program will be very simple: you need to write a ***command handler*** which will take a string (like `led_toggle`) and call a function which will do a certain action, in this case switch the led.
-
-The problem statement is clear, now let's look at the implementation of this program. I will use the MPLAB X IDE and the C language to write the firmware.
-
-## Necessary constants
-
-First, we define a list of constants for the whole project by creating a file `constants.h`:
-
-```c
-#ifndef CONSTANTS_H
-#define	CONSTANTS_H
-
-#define F_CPU           4000000UL
-#define BAUD_RATE       9600
-#define BUFFER_SIZE     20
-#define EOT             0x04
-
-#endif	/* CONSTANTS_H */
-```
-
-* `F_CPU` - microcontroller clock speed
-* `BAUD_RATE` - UART bit rate
-* `BUFFER_SIZE` - buffer size, where we will put the incoming data
-* `EOT` - End-of-Transmission, ASCII character for the end of data transfer
-
-## USART initialization
-
-Create a header file `usart.h` and define some functions to initialize USART, send a char and string.
-
-```c
-#include "constants.h"
-
-#ifndef USART_H
-#define	USART_H
-#define USART1_BAUD_RATE(BAUD_RATE) ((float)(64 * F_CPU / (16 * (float)BAUD_RATE)) + 0.5)
-
-#include <avr/io.h>
-#include <stdio.h>
-#include <string.h>
-
-void USART1_Initialize(void);
-void USART1_SendChar(char c);
-void USART1_SendString(char *str);
-
-#endif	/* USART_H */
-```
-
-The macro `USART1_BAUD_RATE` calculates the value to write to the register `USARTn.BAUD` to set the baud rate. The formula is taken from [documentation](https://ww1.microchip.com/downloads/aemDocuments/documents/MCU08/ProductDocuments/DataSheets/AVR128DA28-32-48-64-Data-Sheet-40002183C.pdf) for the microcontroller (chapter 25.3.2.2.1, table 25-1).
-
-Let's implement the USART initialization function in the file `usart.c`:
-
-```c
-void USART1_Initialize(void) {
-  /* set baud rate */
-  USART1.BAUD = (uint16_t) (USART1_BAUD_RATE(BAUD_RATE));
-
-  /* set char size in a frame to 8 bit */
-  USART1.CTRLC = USART_CHSIZE0_bm | USART_CHSIZE1_bm;
-
-  /* config pins for TX and RX */
-  PORTC.DIRSET = PIN0_bm;
-  PORTC.DIRCLR = PIN1_bm;
-
-  /* enable reveice complete interrupt */
-  USART1.CTRLA = USART_RXCIE_bm;
-
-  /* enable transmitter and receiver */
-  USART1.CTRLB = USART_TXEN_bm | USART_RXEN_bm;
-}
-```
-
-For full-duplex mode initialization of the asynchronous version of USART is as follows:
-
-* Configuration of the baud rate by writing a value to the register `USARTn.BAUD`.
-* Configuration of the `frame` size, in our case it is 8 bits.
-* Configuration of the `TX` pin for output and `RX` pin for input.
-* Enabling an interrupt for when the data reception is over (when one packet has arrived).
-* Enabling the receiver and transmitter.
-
-Now, let's take a look at the functions of sending data:
-
-```c
-void USART1_SendChar(char c) {
-  while (!(USART1.STATUS & USART_DREIF_bm));
-
-  USART1.TXDATAL = c;
-}
-
-void USART1_SendString(char *str) {
-  for (size_t i = 0; i < strlen(str); i++) {
-    USART1_SendChar(str[i]);
-  }
-}
-```
-
-To send data you must write one byte to the `USARTn.TXDATAL` register, but before doing so you must ensure that the previous transfer was completed by checking the `USARTn.STATUS` register. As stated in the documentation, the `DREIF` (Data Register Empty Flag) bit is set if the data in the TX buffer is **absent**. Accordingly it is possible to make an empty loop which will run as long as we have data in the TX buffer.
-
-The send string function is a kind of wrapper which will call the send one character function.
-
-## Command Handler
-
-As you can see from the problem statement, we get a string that tells us what action should be executed.
-
-Let's define a header file `command.h` and write the following in it:
-
-```c
-#ifndef COMMAND_H
-#define	COMMAND_H
-
-#include <avr/io.h>
-#include <string.h>
-
-#define COMMAND_SIZE 5
-#define COMMAND_MAX_NAME_LENGTH 20
-
-struct Command {
-  void *addr;
-  char name[COMMAND_MAX_NAME_LENGTH];
-};
-
-uint8_t command_define(void *fp, char name[COMMAND_MAX_NAME_LENGTH]);
-uint8_t command_process(char *cmd_name);
-void command_list(void);
-
-#endif	/* COMMAND_H */
-```
-
-To solve this problem, I propose to create an array of structures, where each structure will contain a pointer to the function we need to execute, and the name of the command itself.
-
-* `command_define` will create a new structure in the array.
-* `command_process` will call the corresponding function on the command name.
-* `command_list` will send information about existing commands via UART.
-
-You can implement this by creating a file `command.c` as follows:
-
-```c
-#include "command.h"
-#include "usart.h"
-
-struct Command commands[COMMAND_SIZE];
-uint8_t cmd_idx = 0;
-
-uint8_t command_define(void *fp, char name[COMMAND_MAX_NAME_LENGTH]) {
-  size_t name_length = strlen(name);
-  if (name_length > COMMAND_MAX_NAME_LENGTH) {
-    return 0;
-  }
-
-  if (cmd_idx > COMMAND_SIZE) {
-    cmd_idx = 0;
-  }
-
-  struct Command command;
-  command.addr = fp;
-  strcpy(command.name, name);
-  commands[cmd_idx++] = command;
-  return 1;
-}
-
-uint8_t command_process(char *cmd_name) {
-  uint8_t i = 0;
-
-  do {
-    if (strcmp(cmd_name, commands[i].name) == 0) {
-      int (*execute)();
-      execute = commands[i].addr;
-      execute();
-      USART1_SendString("[LOG]: Command completed successfully with code \"0\".\n");
-      USART1_SendChar(EOT);
-      return 0;
-    }
-  } while (i++ < COMMAND_SIZE);
-
-  USART1_SendString("[LOG]: Invalid command name!\n");
-  USART1_SendChar(EOT);
-
-  return 1;
-}
-
-void command_list(void) {
-  USART1_SendString("[LOG]: List of available commands:\n");
-  for (uint8_t i = 0; i < COMMAND_SIZE; i++) {
-    if (commands[i].addr) {
-      USART1_SendChar((i + 1) + '0');
-      USART1_SendString(". ");
-      USART1_SendString(commands[i].name);
-      USART1_SendChar('\n');
-    }
-  }
-}
-```
-
-It is important to note that after sending the data, you must send the `EOT` symbol, which will tell you that the transmission is complete, this will help in the future development of the web application.
-
-## Receiving data
-
-The last thing to do is to receive commands from USART and send them to a handler. You can use an interrupt to do this:
-
-```c
-char buffer[BUFFER_SIZE];
-volatile uint8_t buff_idx = 0;
-
-ISR(USART1_RXC_vect) {
-  if (buff_idx > BUFFER_SIZE) buff_idx = 0;
-  buffer[buff_idx] = USART1.RXDATAL;
-  buff_idx++;
-}
-```
-
-When the interrupt `USART1_RXC_vect` is triggered, data (one byte) appears in the `USART1.RXDATAL` register. This byte we have to write to our fixed size buffer. There is also another way to accept data without using an interrupt. To do this simply check the bit `RXCIF` (USART Receive Complete Interrupt Flag) in the register `USARTn.STATUS`. This bit is set when there is data in the receive buffer.
-
-In order to process incoming commands you can check the buffer in the main loop for the `\n` character, this character will signify the end of the command name:
-
-```c
-while (1) {
-	if (buff_idx >= 1) {
-	  if (buffer[buff_idx - 1] == '\n') {
-	    buffer[buff_idx - 1] = '\0';
-	    command_process(buffer);
-	    buff_idx = 0;
-	  }
-	}
-}
-```
-
-After finding this character, you can pass the buffer to the handler, then reset the buffer index to zero. As a result, the `main.c` file will look like this
-
-```c
-#include <avr/io.h>
-#include <avr/interrupt.h>
-#include <string.h>
-#include "constants.h"
-#include "command.h"
-#include "usart.h"
-
-char buffer[BUFFER_SIZE];
-volatile uint8_t buff_idx = 0;
-
-void led_toggle(void);
-void hello_world(void);
-
-ISR(USART1_RXC_vect) {
-  if (buff_idx > BUFFER_SIZE) buff_idx = 0;
-  buffer[buff_idx] = USART1.RXDATAL;
-  buff_idx++;
-}
-
-void MCU_Init_Ports(void) {
-  /* led pin PC6 to output */
-  PORTC.DIRSET = PIN6_bm;
-}
-
-int main(void) {
-  MCU_Init_Ports();
-  USART1_Initialize();
-  sei();
-
-  command_define(led_toggle, "led_toggle");
-  command_define(hello_world, "hello");
-  command_define(command_list, "list");
-
-  while (1) {
-    if (buff_idx >= 1) {
-      if (buffer[buff_idx - 1] == '\n') {
-        buffer[buff_idx - 1] = '\0';
-        command_process(buffer);
-        buff_idx = 0;
-      }
-    }
-  }
-}
-
-void led_toggle(void) {
-  PORTC.OUTTGL = PIN6_bm;
-}
-
-void hello_world(void) {
-  USART1_SendString("Hello world!\n");
-}
-```
-
-After initialization of the microcontroller ports and USART it is obligatory to enable the global interrupts by calling the function `sei`.
-
-With the function `command_define` we can define by which USART command to start the function:
-
-* `led_toggle` will toggle the LED.
-* `hello_world` will output the message "Hello world".
-* `command_list` will show a list of available commands.
-
-## Operation demonstration
-
-Now with the firmware assembled and loaded into your Microcontroller you can test it's functionality. I will use the program `CuteCom` to open the serial port, you can use any other similar program.
-
-Select your device from the list (in my case it is `/dev/ttyACM1`) and set the following parameters:
-
-* Speed: **9600** baud
-* Number of bits: **8**
-* Parity: **None**
-* Stop bits: **1**
-
-<figure>
-	<img
-		src="/media/uart-connect-settings.png"
-		width="700"
-		height="400"
-		alt="Settings for opening a serial port"
-		format="webp"
-    fit="fill"
-	>
-	<figcaption>Settings for opening a serial port</figcaption>
-</figure>
-
-Now after opening the port you can send commands, don't forget to set the carriage return as `LF`, because our firmware only recognizes the end of the command by this character.
-
-<figure>
-	<img
-		src="/media/webserial-demo-1.png"
-		width="700"
-		height="400"
-		alt="An example of sending the ”hello” command"
-		format="webp"
-    fit="fill"
-	>
-	<figcaption>An example of sending the ”hello” command</figcaption>
-</figure>
-
-# Web application development
-
-The web application will consist of just a few elements: an input box where we can write our commands, buttons to open and close the serial port, connection status. You can see the finished version [here](https://web-serial-example.netlify.app/).
-
-## Create HTML markup and styles
-
-The HTML markup will look like this:
-
-```html
-<!DOCTYPE html>
-<html lang="en">
-	<head>
-		<meta charset="UTF-8" />
-		<meta http-equiv="X-UA-Compatible" content="IE=edge" />
-		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
-		<title>Web Serial API Example</title>
-		<link href="./style.css" rel="stylesheet" />
-		<script defer src="./app.js"></script>
-	</head>
-	<body>
-		<div id="app">
-			<div>
-				<button id="connect">Connect</button>
-				<button id="disconnect">Disconnect</button>
-			</div>
-			<form id="terminal_form" action="#">
-				<label for="input">Enter command name:</label><br />
-				<div>
-					<input id="input" name="input" placeholder="e.g led_toggle" type="text" disabled />
-					<button name="send" type="submit" disabled>Send</button>
-				</div>
-			</form>
-			<textarea id="serial_log" placeholder=">" readonly></textarea>
-			<div id="port_info">
-				<div>
-					<p id="status">not connected</p>
-				</div>
-				<div>
-					<span>vendorId: <span id="vendor_id">-</span>&nbsp;|</span>
-					<span>deviceId: <span id="product_id">-</span></span>
-				</div>
-			</div>
-		</div>
-	</body>
-</html>
-```
-
-Let's add some styles by creating a `style.css` file:
-
-```css
-:root {
-	--border-color: #c9d1d9;
-	--border-color-hover: #6e7681;
-	--font-family: monospace;
-}
-
-*,
-*:before,
-*:after {
-	box-sizing: inherit;
-}
-
-#app {
-	display: flex;
-	flex-direction: column;
-	width: 100%;
-	max-width: 600px;
-	row-gap: 5px;
-}
-
-html,
-body {
-	box-sizing: border-box;
-	font-size: 16px;
-}
-
-body {
-	display: flex;
-	justify-content: center;
-	margin-top: 2rem;
-	font-family: var(--font-family);
-}
-
-p {
-	padding: 0;
-	margin: 5px;
-}
-
-input,
-textarea {
-	font-family: var(--font-family);
-	padding: 5px 15px;
-	border-radius: 4px;
-	width: 100%;
-	border: 1px solid var(--border-color);
-}
-
-textarea {
-	resize: vertical;
-	min-height: 200px;
-	line-height: 1.4;
-	font-size: 16px;
-	outline: none;
-	font-size: 12px;
-}
-
-label {
-	font-size: 14px;
-	font-style: italic;
-}
-
-button {
-	cursor: pointer;
-	background: none;
-	font-family: var(--font-family);
-	border: 1px solid var(--border-color);
-	border-radius: 4px;
-	padding: 5px 15px;
-}
-
-button:hover:not(:disabled) {
-	border: 1px solid var(--border-color-hover);
-}
-
-#terminal_form div {
-	display: flex;
-	justify-content: space-between;
-	gap: 5px;
-	margin-bottom: 5px;
-	margin-top: 5px;
-}
-
-#port_info {
-	display: flex;
-	justify-content: space-between;
-	align-items: center;
-	flex-wrap: wrap;
-	font-size: 14px;
-}
-
-#port_info #status {
-	text-transform: uppercase;
-}
-```
-
-## Creating a SerialPortHandler class
-
-The logic of working with serial port will be implemented in this class, which will be a small wrapper for easy use of WebSerial API, it will have only 5 methods and a few properties.
-
-Let's define this class in the `app.js` file:
-
-```jsx
-class SerialPortHandler {
-	constructor(options, onConnect, onDisconnect) {
-		this.encoder = new TextEncoder();
-		this.decoder = new TextDecoder();
-		this.onConnect = onConnect;
-		this.onDisconnect = onDisconnect;
-		this.options = options;
-		this.port = null;
-		this.isOpened = false;
-		this.#setupListeners();
-	}
-
-	async open() {}
-
-	async close() {}
-
-	async write(data) {}
-
-	async read() {}
-
-	#setupListeners() {}
-}
-```
-
-* [`TextEncoder`](https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder) is a class that encodes a string into an array of unsigned 8-bit integers [`Uint8Array`](https://webidl.spec.whatwg.org/#idl-Uint8Array).
-* [`TextDecoder`](https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder#examples), on the contrary, decodes into a string. We will need instances of these classes, because we will be operating with data of type `Uint8Array`.
-* The `onConnect` and `onDisconnect` functions will be called when the device is connected or disconnected.
-* The [`options`](https://wicg.github.io/serial/#serialoptions-dictionary) property contains the necessary parameters that will be used for transmitting and receiving data.
-* Property [`port`](https://wicg.github.io/serial/#serialport-interface) - object which will contain methods for working with the port and information about the device after the connection is established.
-* The function `setupListeners` will simply add event handlers.
-
-The following is the implementation of these methods.
-
-## Opening a serial port
-
-To open a serial port you first need to call the [`requestPort`](https://wicg.github.io/serial/#requestport-method) method which will open a special window with a list of devices. It is also necessary that the user himself activate the call to this window, otherwise there will be an error. This can be done just by the event of pressing the button.
-
-```jsx
-async open() {
-  try {
-    const port = await navigator.serial.requestPort();
-    await port.open(this.options);
-
-    this.port = port;
-    this.isOpened = true;
-
-    return this.port.getInfo();
-  } catch (error) {
-    console.error(error);
-    throw error;
-  }
-}
-```
-
-You can pass an optional filter parameter to the `requestPort` function, which will limit the list of selectable ports according to the USB ID:
-
-```jsx
-const port = await navigator.serial.requestPort({
-	filters: [{ usbVendorId: 0x7522 }],
-});
-```
-
-A list of USB IDs can be found at [this](https://devicehunt.com/all-usb-vendors).
-
-<figure>
-	<img
-		src="/media/webserial-connect.png"
-		width="700"
-		height="400"
-		alt="Selecting a device through a special window"
-		format="webp"
-                fit="fill"
-	>
-	<figcaption>Selecting a device through a special window</figcaption>
-</figure>
-
-After the user has selected the device, the `requestPort` method returns [`port`](https://wicg.github.io/serial/#serialport-interface) which can be opened by passing [parameters](https://wicg.github.io/serial/#serialoptions-dictionary) there:
-
-* `baudRate` : baud rate.
-* `dataBits` : number of data bits in the frame (7 or 8).
-* `stopBits` : number of stop bits at the end of the packet (1 or 2).
-* `parity` : parity mode ( `none` , `even` or `odd` ).
-* `bufferSize` : the size of the read and write buffers to be created.
-* `flowControl` : flow control mode ( `none` or `hardware`).
-
-The `baudRate` property is the only mandatory parameter, the others are optional and have [default values](https://wicg.github.io/serial/#serialoptions-dictionary).
-
-At the end our method returns [information](https://wicg.github.io/serial/#dom-serialportinfo) about the connected device using the method [`getInfo`](https://wicg.github.io/serial/#dom-serialport-getinfo).
-
-## Read data
-
-Note that the WebSerial API is asynchronous, which prevents the user interface from locking up while accepting data.
-
-It is also important to know that the WebSerial API uses streams [Stream API](https://streams.spec.whatwg.org/). When streaming, the data is split into `(chunks)`, this allows the data to be processed without completely waiting for it to arrive.
-
-Receiving data can be implemented as follows:
-
-```jsx
-async read() {
-  while (this.port.readable) {
-    const reader = this.port.readable.getReader();
-    let chunks = '';
-
-    try {
-      while (true) {
-        const { value, done } = await reader.read();
-        const decoded = this.decoder.decode(value);
-
-        chunks += decoded;
-
-        if (done || decoded.includes(EOT)) {
-          console.log('Reading done.');
-          reader.releaseLock();
-          break;
-        }
-      }
-      return chunks;
-    } catch (error) {
-      console.error(error);
-      throw error;
-    } finally {
-      reader.releaseLock();
-    }
-  }
-}
-```
-
-When the user has connected to the device, `this.port` will have properties like `writable` and `readable` which are instances of the [WritableStream](https://streams.spec.whatwg.org/#writablestream) and [ReadableStream](https://streams.spec.whatwg.org/#readablestream) classes. We will need them to read and write data.
-
-The external `while` loop is for error checking, such as parity checks. If a fatal error occurs, the `readable` property will become `null`.
-
-The method [`getReader`](https://streams.spec.whatwg.org/#rs-get-reader) creates [reader](https://streams.spec.whatwg.org/#reader) which will allow to get data in fragments. A readable thread has no more than one reader at a time, so after that the thread is **[locked](https://streams.spec.whatwg.org/#lock)**, but the reader remains **active**.
-
-The internal `while` loop reads data using the `read` method of the reader. This method returns the `value` property, which has data of type `UInt8Array`, and the `done` property, which becomes `true` if the serial device no longer transmits any data. Then we decode the data into a string and write it into the `chunks` variable. There is also a check for the `EOT` (End-of-Transmission) character, which means the end of the data transfer. Define this character at the beginning of the `app.js` file as a global variable:
-
-```jsx
-var EOT = "\u0004";
-```
-
-After the end of data reception, the thread must be unlocked by calling the `releaseLock` method to make the reader inactive.
-
-## Write data
-
-In order to send data to a serial device, you must create a [writer](https://streams.spec.whatwg.org/#writer) that will provide the ability to send snippets to the writing stream:
-
-```jsx
-async write(data) {
-    const writer = this.port.writable.getWriter();
-    const encoded = this.encoder.encode(data);
-    await writer.write(encoded);
-    writer.releaseLock();
-  }
-```
-
-Before sending, you need to encode your string into data of type `UInt8Array`. After creating a writer, the writing thread is also locked, so after writing it must be unlocked using the same `releaseLock` method.
-
-## Closing a port
-
-You can use the [`close`](https://wicg.github.io/serial/#dom-serialport-close) method to close a port when communication with the device is no longer needed:
-
-```jsx
-async close() {
-  await this.port.close();
-  this.isOpened = false;
-}
-```
-
-The port cannot be closed when the thread that is writing or reading is blocked.
-
-## Event Handling
-
-The API allows you to subscribe to events when a trusted device connects or when it disconnects:
-
-```jsx
-#setupListeners() {
-  navigator.serial.addEventListener('connect', this.onConnect);
-  navigator.serial.addEventListener('disconnect', this.onDisconnect);
-}
-```
-
-## Using the created class
-
-Now you can write the front-end part of the web application using our created class `SerialPortHandler`:
-
-```jsx
-class Application {
-	constructor(root) {
-		if (!("serial" in navigator)) {
-			console.error("Web Serial API is not supported in your browser.");
-			return;
-		}
-
-		this.serialPortHandler = new SerialPortHandler(
-			{ baudRate: 9600 },
-			() => console.log("Device connected."),
-			() => {
-				console.log("Device disconnected.");
-				this.#disconnectHandler();
-			}
-		);
-
-		/**
-		 * DOM Elements
-		 */
-		this.$root = root;
-		this.$connectButton = this.$root.querySelector("#connect");
-		this.$disconnectButton = this.$root.querySelector("#disconnect");
-		this.$terminalForm = this.$root.querySelector("#terminal_form");
-		this.$serialLog = this.$root.querySelector("#serial_log");
-		this.$status = this.$root.querySelector("#status");
-		this.$vendorId = this.$root.querySelector("#vendor_id");
-		this.$productId = this.$root.querySelector("#product_id");
-
-		this.#setupEvents();
-	}
-
-	/**
-	 * Handlers for connecting, disconnecting and sending a command
-	 */
-	#setupEvents() {
-		this.$connectButton.addEventListener("click", this.#connectHandler.bind(this));
-		this.$disconnectButton.addEventListener("click", this.#disconnectHandler.bind(this));
-		this.$terminalForm.addEventListener("submit", this.#submitHandler.bind(this));
-	}
-
-	/**
-	 * Open serial port and notify user of connection status
-	 * @returns {Promise<void>}
-	 */
-	async #connectHandler() {
-		try {
-			if (this.serialPortHandler.isOpened) return;
-			const info = await this.serialPortHandler.open();
-			console.log("Port opened: ", info);
-			this.$terminalForm.elements.input.removeAttribute("disabled");
-			this.$terminalForm.elements.send.removeAttribute("disabled");
-			this.$vendorId.textContent = "0x" + info.usbVendorId.toString(16);
-			this.$productId.textContent = "0x" + info.usbProductId.toString(16);
-			this.$status.textContent = "CONNECTED";
-		} catch (error) {
-			this.$status.textContent = "ERROR";
-		}
-	}
-
-	/**
-	 * Closes the serial port and updates the connection status.
-	 * @returns {Promise<void>}
-	 */
-	async #disconnectHandler() {
-		if (!this.serialPortHandler.isOpened) return;
-		await this.serialPortHandler.close();
-		this.$terminalForm.elements.input.setAttribute("disabled", "true");
-		this.$terminalForm.elements.send.setAttribute("disabled", "true");
-		this.$vendorId.textContent = "-";
-		this.$productId.textContent = "-";
-		this.$status.textContent = "NOT CONNECTED";
-	}
-
-	/**
-	 * Writes data to the serial port and reads the response
-	 * @param {SubmitEvent} e - Form submit event
-	 */
-	async #submitHandler(e) {
-		e.preventDefault();
-		const $form = e.target;
-		const data = $form.elements.input.value;
-		$form.reset();
-		if (this.serialPortHandler.isOpened && data) {
-			this.$serialLog.innerHTML += ">" + data + "\n";
-			await this.serialPortHandler.write(data + "\n");
-			const message = await this.serialPortHandler.read();
-			this.$serialLog.textContent += message.replaceAll(EOT, "");
-			console.log("Message received: \n" + message);
-		}
-		this.$serialLog.scrollTo(0, this.$serialLog.scrollHeight);
-	}
-}
-```
-
-Basically there is a work with interface updates and I think it is not necessary to explain the logic in detail, I will note only the key points:
-
-In the constructor of this class, you can determine whether the browser supports WebSerial API by checking the `serial` key in the `navigator` object, and if not, we write an error to the console. Object `this.serialPortHandler` will be an instance of our created class `SerialPortHandler`, we pass the speed **9600** and functions which will be the handlers of events to connect and disconnect the device as arguments. Then we look for the necessary DOM elements and add an event listener to some of them.
-
-The `#submitHandler` method is designed to send commands and accept the result of command execution. When you use the `write` method, be sure to add a `\n` character at the end, so the program in the microcontroller knows where the command name ends.
-
-Initialize the application at the end of the `app.js` file:
-
-```js
-new Application(document.getElementById("app"));
-```
-
-## Checking the web application
-
-You can now send commands to the microcontroller:
-
-<figure>
-	<img
-		src="/media/webserial-demo-2.png"
-		width="550"
-		height="300"
-		alt="The finished result of the web application"
-		format="webp"
-	>
-	<figcaption>The finished result of the web application</figcaption>
-</figure>
-
-For fun, you can flash the LED:
-
-```js
-const app = new Application(document.getElementById("app"));
-
-setInterval(async () => {
-	if (app.serialPortHandler.isOpened) {
-		await app.serialPortHandler.write("led_toggle" + "\n");
-		const message = await app.serialPortHandler.read();
-		console.log(message);
-	}
-}, 500);
-```
-
-<figure>
-  <img src="/media/webserial-demo-3.gif" loading="lazy" alt="blinking LED" />
-  <figcaption>Blinking LED</figcaption>
-</figure>
-
-# Conclusion
-
-Having developed the web application we have seen that using the WebSerial API is quite easy. I hope that this article will be useful to you and help you in developing your project.
-
-# Useful stuff
-
-* [Browser support status Can I use](https://caniuse.com/web-serial)
-* [WebSerial API documentation](https://wicg.github.io/serial/)
-* [Stream API detailed guide](https://web.dev/streams/)
-* [USB ID list](https://devicehunt.com/all-usb-vendors)
-* [Access to different devices from the browser](https://web.dev/devices-introduction/)
\ No newline at end of file
diff --git a/src/content/blog/en/реализация-задержек-в-avr-микроконтроллере.md b/src/content/blog/en/реализация-задержек-в-avr-микроконтроллере.md
deleted file mode 100644
index 1e87081..0000000
--- a/src/content/blog/en/реализация-задержек-в-avr-микроконтроллере.md
+++ /dev/null
@@ -1,612 +0,0 @@
----
-coverImage: null
-draft: true
-author: Sergey Yarkov
-title: Implementation of delays in the AVR microcontroller
-description: Очень часто в программах приходится выполнять задержку. Например
-  при реализации какого либо протокола необходимо в точности выдерживать
-  тайминги, или же необходимо выполнять какую либо логику раз в несколько часов
-  или дней. В этой статье рассмотрены несколько способов реализации задержек.
-tags:
-  - AVR
-  - Tutorial
-pubDate: 2023-10-15T16:28:52.587Z
-updatedDate: 2023-10-15T16:28:52.601Z
----
-
-# Способы реализации
-
-Существует два способа как можно реализовать задержку - это использовать аппаратные таймеры микроконтроллера или использовать простой цикл который выполняется определенное количество тактов. Преимущество использования аппаратного таймера микроконтроллера перед обычным программным циклом заключается в неблокирующем выполнении программы за счет того что работа таймера-счетчика не зависит от выполнения основной программы. Но иногда нужно использовать задержку всего в несколько микросекунд, что особо не повлияет на работу программы в некоторых случаях, тогда можно посмотреть в сторону простых циклов. Будет рассмотрен вариант и с длительной задержкой в несколько часов или дней. Программы будут представлены на языке Си и Ассемблера для микроконтроллера AVR ATtiny45V. В качестве основной программы будет моргающий светодиод который переключается раз в 0.5 секунд.
-
-## Используем цикл
-
-Для реализации этого способа задержки для начала нужно посчитать кол-во тактов процессора для выполнения задержки в N секунд и затем сделать цикл. Например для МК с частотой в 8 MHz один такт будет равен `1/8 = 0.125uS`. Значит чтобы рассчитать кол-во тактов например в 0.5 секунд то это будет `(0.5 × 1,000,000) × 8 = 4,000,000` тактов, т.е половина от частоты МК.
-
-Реализация цикла задержки на ассемблере:
-
-```asmatmel
-.MACRO	delay16
-	ldi		delay8_r, LOW(@0 * F_CPU / 4 - 3)			; 1
-	ldi		delay16_r, HIGH(@0 * F_CPU / 4 - 3)		; 1
-	rcall	DELAY16_LOOP													; 3
-.ENDMACRO
-
-DELAY16_LOOP:
-	subi	delay8_r, 1			                      ; 1
-	sbci	delay16_r, 0		                      ; 1
-	brcc	DELAY16_LOOP		                      ; 1 = false, 2 = true
-	ret							                            ; 4
-```
-
-Каждая инструкция в микроконтроллере выполняется за определенное кол-во тактов (комментарии в коде выше). Например инструкция `ldi` выполняется за один такт, а инструкция `brcc` выполняется за два такта - когда условие верно и за один такт когда условие неверно. На кол-во тактов так же влияет и разрядность программного счетчика (см. [AVR Instruction Set](http://ww1.microchip.com/downloads/en/devicedoc/atmel-0856-avr-instruction-set-manual.pdf)).
-
-### Пояснения к программе
-
-В данной реализации используется макрос `delay16` который загружает кол-во тактов в два 8-ми битных регистра которые помечены как младший и старший. Затем вызывается подпрограмма выполнения цикла. Зачем нужно в расчете тактов делить полученное число на 4? Посмотрите на подпрограмму `DELAY16_LOOP` которая выполняет декрементирование 16-ти битного числа, вы увидите что одна итерация цикла занимает 4 такта. От полученного числа отнимаем 3 для компенсации времени.
-
-В итоге максимальная задержка которая может получиться при работе МК в 8 MHz вызвав этот макрос равняется `65535/8 * 4 = 32767.5uS` что не совсем подходит для мигания светодиодом. Что бы сделать задержку дольшо можно использовать 24 бита для хранения кол-ва тактов. Тогда максимальная задержка составит `16,777,216/8 * 5 = 10.48сек`. В итоге получается такая программа с переключающимся светодиодом раз в 0.5 секунд:
-
-```asmatmel
-.EQU	F_CPU			      = 8 ; MHz
-
-.DEF	t1			        = r16
-.DEF	t2			        = r17
-.DEF	delay24_r		    = r18
-.DEF	delay16_r		    = r19
-.DEF	delay8_r		    = r20
-
-.EQU	LED_DDR			    = DDRB
-.EQU	LED_PORT		    = PORTB
-.EQU	LED_PIN_DATA		= PINB
-.EQU	LED_PIN			    = PB0
-
-.MACRO	delay24
-    ldi		delay8_r, LOW(@0 * F_CPU / 5 - 3)
-    ldi		delay16_r, HIGH(@0 * F_CPU / 5 - 3)
-    ldi		delay24_r, BYTE3(@0 * F_CPU / 5 - 3)
-    rcall	DELAY24_LOOP
-.ENDMACRO
-
-.CSEG
-
-.ORG 	0x00
-    rjmp		RESET_vect
-
-RESET_vect:
-    ldi		t1, LOW(RAMEND)
-    out		SPL, t1
-
-INIT:
-    ldi		t1, (1<<LED_PIN)
-    out		LED_DDR, t1
-    clr		t1
-    out		LED_PORT, t1
-
-LOOP:
-    nop
-    delay24	500000
-    nop
-    rcall	LED_TOGGLE
-    rjmp	LOOP
-
-LED_TOGGLE:
-    push	t1
-    push	t2
-    in		t1, LED_PIN_DATA
-    ldi		t2, (1<<LED_PIN)
-    eor		t1, t2
-    out		LED_PORT, t1
-    pop		t2
-    pop		t1
-    ret
-
-DELAY24_LOOP:
-    subi	delay8_r, 1
-    sbci	delay16_r, 0
-    sbci	delay24_r, 0
-    brcc	DELAY24_LOOP
-    ret
-```
-
-Выполнить компиляцию:
-
-```bash
-avrasm2 -fI ./main.asm
-```
-
-Если использовать 32 бита для хранения кол-ва тактов то максимальная задержка уже составит 3221 секунда! Также вместо регистров общего назначения можно использовать ячейки, определенные в оперативной памяти (SRAM).
-
-Чтобы проверить точно ли выполняется задержка, воспользуемся симулятором который встроен в IDE MPLAB X. Перед этим необходимо настроить частоту работы МК в конфигурации проекта:
-
-<figure>
-	<img src="/media/mplabx-ide-sim-option.png" alt="Выбор частоты выполнения инструкций для симулятора">
-	<figcaption>Выбор частоты выполнения инструкций для симулятора</figcaption>
-</figure>
-
-Установим точки останова на холостые операции **nop** до и после вызова макроса и выполним отладку:
-
-![Отладка программы](/media/screen-1.png)
-
-До вызова инструкции **nop** прошло 8 тактов или 1 микросекунда. Очищаем Stopwatch и нажимаем кнопку продолжения программы (F5):
-
-![Отладка программы](/media/screen-2.png)
-
-Можно видеть что после выхода из подпрограммы `DELAY24_LOOP` прошло ровно 500 миллисекунд.
-
-Для языка Си все будет довольно просто. Библиотека [AVR Libc](https://www.nongnu.org/avr-libc/) поставляется с набором утилит которые упрощают программирование. Поэтому нам достаточно указать частоту МК и вызвать определенную функцию. Эта функция как раз из рассчитает нужное кол-во тактов процессора и выполнит цикл.
-
-Код основной программы на языке Си:
-
-```c
-#define F_CPU 8000000
-
-#include <avr/io.h>
-#include <util/delay.h>
-
-#define PIN_LED PB0
-
-int main(void) {
-  DDRB |= _BV(PIN_LED);
-  PORTB = 0x00;
-  for(;;) {
-    _delay_ms(500);
-    PORTB ^= _BV(PIN_LED);
-  }
-  return 0;
-}
-```
-
-Выполнить компиляцию:
-
-```c
-avr-gcc -Wall -mmcu=attiny45 -Os main.c
-avr-objcopy -j .text -j .data -O ihex a.out main.hex
-```
-
-## Используем таймеры
-
-Что если программе не нужно затрачивать процессорное время на выполнение цикла задержки? Как отмечалось ранее работа таймера-счетчика не зависит от выполнения программы. Счетчик может инкрементироваться хоть раз в секунду при работе процессора с частотой в 8MHz. Существует несколько способов как сделать задержку используя 8-ми или 16-ти битные таймеры. Я опишу некоторые из них.
-
-### 8-ми битный таймер с предделителем 16384
-
-Для микроконтроллера ATtiny45V имеются только 8-ми битные таймеры, причем у одного из них (TIMER1) имеется делитель частоты на 16384 что очень удобно:
-
-<figure>
-	<img src="/media/screen-3.png" alt="Таблица выбора предделителя для таймера-счетчика 1">
-	<figcaption>Таблица выбора предделителя для таймера-счетчика 1</figcaption>
-</figure>
-
-Будем использовать таймер в CTC (Clear on Timer Compare match) режиме. Итоговая частота работы таймера-счетчика будет равна: `8MHz/16384 = 488.28Hz`. Один тик таймера будет равняться `1/488.28 = 2048uS`. Значит для 0.5 секунд значение счетчика будет равняться `0.5×488.38 = 244.14` тиков что достаточно для 8-бит. Будем записывать число в регистр сравнения `OCRn` и генерировать прерывание при совпадении.
-
-Программа на ассемблере:
-
-```asmatmel
-.DEF	t1			      = r16
-.DEF	t2			      = r17
-
-.EQU	LED_DDR			  = DDRB
-.EQU	LED_PORT		  = PORTB
-.EQU	LED_PIN_DATA	= PINB
-.EQU	LED_PIN			  = PB0
-
-.CSEG
-
-.ORG 	0x00
-    rjmp	RESET_vect
-
-.ORG	0x03
-    rjmp	TIMER1_COMPA
-
-RESET_vect:
-    ldi		t1, LOW(RAMEND)
-    out		SPL, t1
-
-INIT:
-    ldi		t1, (1<<LED_PIN)
-    out		DDRB, t1
-    clr		t1
-    out		LED_PORT, t1
-
-    ; ========= Setup 8-bit timer-1 in CTC mode with 16384 prescaler =============
-    ; CPU Clock Freq = 8MHz
-    ; Freq(t) = 8MHz / 16384 = 488.28125 Hz
-    ; Tick = 1 / Freq(t) = 1 / 488.28125 = 2048uS (0.002048 sec)
-    ; Ticks = 0.5 sec / 0.002048 sec = 244
-    ; ============================================================================
-    ldi		t1, (1<<CTC1) | (1<<CS13) | (1<<CS12) | (1<<CS11) | (1<<CS10)
-    out		TCCR1, t1							    ; setup timer
-    clr 	t1								        ; clear timer counter register
-    out		TCNT1, t1
-    ldi		t1, 244								    ; 0.5 sec
-    out		OCR1A, t1
-    out 	OCR1C, t1							    ; for clearing timer on compare match
-    ldi		t1, (1<<OCIE1A)						; enable output compare A interrupt
-    out		TIMSK, t1
-
-    sei
-
-LOOP:
-    nop
-    rjmp	LOOP
-
-LED_TOGGLE:
-    push	t1
-    push	t2
-    in		t1, LED_PIN_DATA
-    ldi		t2, (1<<LED_PIN)
-    eor		t1, t2
-    out		LED_PORT, t1
-    pop		t2
-    pop		t1
-    ret
-
-TIMER1_COMPA:
-    push	t1
-    in		t1, SREG
-    rcall	LED_TOGGLE
-    out		SREG, t1
-    pop		t1
-    reti
-```
-
-Программа на языке Си:
-
-```c
-#define F_CPU 8000000
-
-#include <avr/interrupt.h>
-#include <avr/io.h>
-
-#define LED_DDR DDRB
-#define LED_PORT PORTB
-#define LED_PIN_DATA PINB
-#define LED_PIN PB0
-
-/*
- * Timer Counter 1
- * Mode: CTC
- * Prescaler: 16384
- */
-void setup_tc1(void) {
-  TCCR1 |= _BV(CTC1) | _BV(CS13) | _BV(CS12) | _BV(CS11) | _BV(CS10);
-  TCNT1 = 0x00;
-  OCR1A = 244;
-  OCR1C = 244;
-  TIMSK |= _BV(OCIE1A);
-}
-
-void setup_ports(void) {
-  DDRB |= _BV(LED_PIN);
-  PORTB = 0x00;
-}
-
-/*
- * Interrupt every 0.5 sec
- */
-ISR(TIMER1_COMPA_vect) {
-  LED_PORT ^= _BV(LED_PIN);
-}
-
-void system_init(void) {
-  setup_ports();
-  setup_tc1();
-  sei();
-}
-
-int main(void) {
-  system_init();
-  for (;;) {
-    asm("nop");
-  }
-  return 0;
-}
-```
-
-### 8-ми битный таймер с предделителем 1024
-
-Что если доступен предделитель частоты только на 1024? Тогда регистр для сравнения `OCRn` будет равняться 3906, что не подходит для 8-ми битного регистра. Как вариант можно считать количество переполнений таймера. `3906.25/255 = 15` переполнений.
-
-Программа на ассемблере:
-
-```asmatmel
-.DEF	t1 			        = r16
-.DEF	t2 			        = r17
-.DEF	tc1_ovf_cnt		  = r18
-
-.EQU	LED_DDR			    = DDRB
-.EQU	LED_PORT		    = PORTB
-.EQU	LED_PIN_DATA		= PINB
-.EQU	LED_PIN			    = PB0
-
-.EQU	TC1_OVF_COMPARE_VAL 	= 15
-
-.CSEG
-
-.ORG 	0x00
-    rjmp		RESET_vect
-
-.ORG	0x04
-    rjmp		TIMER1_OVF
-
-RESET_vect:
-    ldi		t1, LOW(RAMEND)
-    out		SPL, t1
-
-INIT:
-    ldi		t1, (1<<LED_PIN)
-    out		DDRB, t1
-    clr		t1
-    out		LED_PORT, t1
-
-    ; ========= Setup 8-bit timer-1 in Normal mode with 1024 prescaler =======================
-    ; CPU Clock Freq = 8MHz
-    ; Freq(t) = 8MHz / 1024 = 7812.5 Hz
-    ; Tick = 1 / Freq(t) = 1 / 7812.5 = 128uS (0.000128 sec)
-    ; Ticks = 0.5 sec / 0.000128 sec = 3906.25
-		; Overflows count = 3906 / 255 = 15
-    ; ======================================================================================
-    ldi		t1, (1<<CS13) | (1<<CS11) | (1<<CS10)
-    out		TCCR1, t1						; setup timer
-    clr 	t1							    ; clear timer counter register
-    out		TCNT1, t1
-    ldi		t1, (1<<TOIE1)			; enable overflow interrupt
-    out		TIMSK, t1
-    sei
-
-LOOP:
-    nop
-    rjmp	LOOP
-
-LED_TOGGLE:
-    push	t1
-    push	t2
-    in		t1, LED_PIN_DATA
-    ldi		t2, (1<<LED_PIN)
-    eor		t1, t2
-    out		LED_PORT, t1
-    pop		t2
-    pop		t1
-    ret
-
-TIMER1_OVF:
-    push	t1
-    in		t1, SREG
-    inc		tc1_ovf_cnt
-    cpi		tc1_ovf_cnt, TC1_OVF_COMPARE_VAL
-    brne	PC+3
-    rcall	LED_TOGGLE
-    clr		tc1_ovf_cnt						; clear timer overflow counter register
-    out		SREG, t1
-    pop		t1
-    reti
-```
-
-Программа на языке Си:
-
-```c
-#define F_CPU 8000000
-
-#include <avr/interrupt.h>
-#include <avr/io.h>
-
-#define TC1_OVF_COMPARE_VAL 15
-
-#define LED_DDR DDRB
-#define LED_PORT PORTB
-#define LED_PIN_DATA PINB
-#define LED_PIN PB0
-
-static volatile uint8_t tc1_ovf_cnt = 0;
-
-/*
- * Timer Counter 1
- * Mode: Normal
- * Prescaler: 1024
- */
-void setup_tc1(void) {
-  TCCR1 |= _BV(CS13) | _BV(CS11) | _BV(CS10);
-  TCNT1 = 0x00;
-  TIMSK |= _BV(TOIE1);
-}
-
-void setup_ports(void) {
-  DDRB |= _BV(LED_PIN);
-  PORTB = 0x00;
-}
-
-ISR(TIMER1_OVF_vect) {
-  tc1_ovf_cnt++;
-  if (tc1_ovf_cnt == TC1_OVF_COMPARE_VAL) {
-    LED_PORT ^= _BV(LED_PIN);
-    tc1_ovf_cnt = 0;
-  }
-}
-
-void system_init(void) {
-  setup_ports();
-  setup_tc1();
-  sei();
-}
-
-int main(void) {
-  system_init();
-  for (;;) {
-    asm("nop");
-  }
-  return 0;
-}
-```
-
-### Длительная задержка
-
-Бывают случаи когда нужно выполнять какую либо логику раз в несколько часов или дней. Решением является завести глобальную переменную где будем хранить количество прошедших секунд с момента начала отсчета таймера, а в прерывании переполнения таймера будем уже сравнивать значение счетчика с заданным числом. Следующая программа переключает светодиод раз в 6 часов.
-
-```asmatmel
-.DEF	t1 			        = r16
-.DEF	t2 			        = r17
-.DEF	tc1_ovf_cnt		  = r18
-
-.EQU	LED_DDR			    = DDRB
-.EQU	LED_PORT		    = PORTB
-.EQU	LED_PIN_DATA		= PINB
-.EQU	LED_PIN			    = PB0
-
-.EQU	TC1_OVF_COMPARE_VAL 	= 30
-
-.DSEG
-.ORG	SRAM_START
-
-ellapsed_seconds: .BYTE 2
-
-.CSEG
-
-.ORG 	0x00
-    rjmp		RESET_vect
-
-.ORG	0x04
-    rjmp		TIMER1_OVF
-
-RESET_vect:
-    ldi		t1, LOW(RAMEND)
-    out		SPL, t1
-
-INIT:
-    ldi		t1, (1<<LED_PIN)
-    out		DDRB, t1
-    clr		t1
-    out		LED_PORT, t1
-
-		sts		ellapsed_seconds, t1
-		sts		ellapsed_seconds+1, t1
-
-    ; ========= Setup 8-bit timer-1 in Normal mode with 1024 prescaler =======================
-    ; CPU Clock Freq = 8MHz
-    ; Freq(t) = 8MHz / 1024 = 7812.5 Hz
-    ; Tick = 1 / Freq(t) = 1 / 7812.5 = 128uS (0.000128 sec)
-    ; Ticks = 1 sec / 0.000128 sec = 7812,5
-		; Overflows count = 7812 / 255 = 30
-    ; ======================================================================================
-    ldi		t1, (1<<CS13) | (1<<CS11) | (1<<CS10)
-    out		TCCR1, t1						; setup timer
-    clr 	t1							    ; clear timer counter register
-    out		TCNT1, t1
-    ldi		t1, (1<<TOIE1)			; enable overflow interrupt
-    out		TIMSK, t1
-    sei
-
-LOOP:
-    nop
-    rjmp	LOOP
-
-LED_TOGGLE:
-    push	t1
-    push	t2
-    in		t1, LED_PIN_DATA
-    ldi		t2, (1<<LED_PIN)
-    eor		t1, t2
-    out		LED_PORT, t1
-    pop		t2
-    pop		t1
-    ret
-
-TIMER1_OVF:
-    push	t1
-    in		t1, SREG
-    inc		tc1_ovf_cnt
-    cpi		tc1_ovf_cnt, TC1_OVF_COMPARE_VAL
-    brne	_TIMER1_OVF_EXIT
-
-		clr		tc1_ovf_cnt												; clear timer overflow counter register
-
-		lds 	r24,ellapsed_seconds
-    lds 	r25,ellapsed_seconds+1
-    adiw 	r24, 1
-		sts 	ellapsed_seconds+1, r25
-    sts 	ellapsed_seconds, r24
-
-		cpi		r24, LOW(21600)
-		sbci	r25, HIGH(21600)
-		brne	_TIMER1_OVF_EXIT
-   	rcall	LED_TOGGLE
-		clr		r25
-		sts		ellapsed_seconds, r25							; clear ellapsed seconds
-		sts		ellapsed_seconds+1, r25						; -----------------------
-
-_TIMER1_OVF_EXIT:
-		out		SREG, t1
-    pop		t1
-    reti
-```
-
-Программа на языке Си:
-
-```c
-#include <avr/interrupt.h>
-#include <avr/io.h>
-
-#define TC1_OVF_COMPARE_VAL 30
-
-#define LED_DDR DDRB
-#define LED_PORT PORTB
-#define LED_PIN_DATA PINB
-#define LED_PIN PB0
-
-static volatile uint8_t tc1_ovf_cnt = 0;
-static volatile uint16_t ellapsed_seconds = 0;
-
-/*
- * Timer Counter 1
- * Mode: Normal
- * Prescaler: 1024
- */
-void setup_tc1(void) {
-  TCCR1 |= _BV(CS13) | _BV(CS11) | _BV(CS10);
-  TCNT1 = 0x00;
-  TIMSK |= _BV(TOIE1);
-}
-
-void setup_ports(void) {
-  DDRB |= _BV(LED_PIN);
-  PORTB = 0x00;
-}
-
-ISR(TIMER1_OVF_vect) {
-  tc1_ovf_cnt++;
-
-  if (tc1_ovf_cnt == TC1_OVF_COMPARE_VAL) {
-    tc1_ovf_cnt = 0;
-    ellapsed_seconds++;
-
-    /* Every 6 hours */
-    if (ellapsed_seconds == 21600) {
-      LED_PORT ^= _BV(LED_PIN);
-      ellapsed_seconds = 0;
-    }
-  }
-}
-
-void system_init(void) {
-  setup_ports();
-  setup_tc1();
-  sei();
-}
-
-int main(void) {
-  system_init();
-  for (;;) {
-    asm("nop");
-  }
-  return 0;
-}
-```
-
-## Заключение
-
-Рассмотрены два основных способа реализации задержки используя таймеры и циклы. Выяснили что используя таймер-счетчик можно сделать задержку, которая не будет блокировать основной поток выполнения программы. Для длительных задержек, где необходимо отслеживать прошедшее время в секундах или часах, можно использовать глобальные переменные.
-
-## Полезные материалы
-
-- [AVR Instruction Set](https://ww1.microchip.com/downloads/en/devicedoc/atmel-0856-avr-instruction-set-manual.pdf)
-- [AVR130: Setup and Use of AVR Timers](https://ww1.microchip.com/downloads/en/Appnotes/Atmel-2505-Setup-and-Use-of-AVR-Timers_ApplicationNote_AVR130.pdf)
-- [AVR Delay Loop Calculator](http://darcy.rsgc.on.ca/ACES/TEI4M/AVRdelay.html)
-- [AVR Timer Calculator](https://eleccelerator.com/avr-timer-calculator/)
diff --git a/src/content/blog/ru/использование-webserial-api-для-общения-с-микроконтроллером.md b/src/content/blog/ru/использование-webserial-api-для-общения-с-микроконтроллером.md
deleted file mode 100644
index ac37334..0000000
--- a/src/content/blog/ru/использование-webserial-api-для-общения-с-микроконтроллером.md
+++ /dev/null
@@ -1,899 +0,0 @@
----
-coverImage: /media/serial-port.jpg
-draft: false
-author: Сергей Ярков
-title: Использование WebSerial API для общения с микроконтроллером
-description: Речь пойдет о том, что такое WebSerial API, как его можно
-  использовать в браузере для чтения и записи данных в последовательное
-  устройство и где его можно применить.
-tags:
-  - JavaScript
-  - AVR
-  - WebSerial API
-  - Tutorial
-pubDate: 2022-11-04T21:00:00.000Z
-updatedDate: 2023-02-13T16:34:23.326Z
----
-# Что вы узнаете
-
-По итогу вы узнаете, как отправлять и принимать данные от устройства с последовательным портом в браузере, разработаете демонстрационное веб-приложение, которое отправляет команды в микроконтроллер с последовательным портом и напишите прошивку для микроконтроллера [AVR128DA48](http://ww1.microchip.com/downloads/en/DeviceDoc/40002183A.pdf) для обработки этих команд. Готовый вариант проекта можно посмотреть [здесь](https://web-serial-example.netlify.app/), исходники загружены в [репозиторий](https://github.com/sergeyyarkov/avr128da48_web-serial-example) на GitHub.
-
-# Что это и где применяется
-
-WebSerial API - это браузерный API, который предоставляет возможность к чтению и записи данных в последовательное устройство. Использование этого API довольно простое, нужно лишь написать несколько строк кода, чтобы получить или отправить ваши данные. К тому же имеется подробная [документация](https://wicg.github.io/serial/), где имеются примеры использования этого API.
-
-Благодаря этому API, открываются новые возможности. Например, вы можете перепрошивать ваш микроконтроллер прямо из браузера, что звучит весьма интересно (но перед этим вам необходимо написать bootloader), или же просто выводить информацию с датчиков на веб страницу. Вариантов применения неограниченно, все зависит только от вашей фантазии.
-
-Еще существуют и высокоуровневые API для доступа к таким устройствам как геймпад или камера. Я оставлю эту ссылку на [эту](https://web.dev/devices-introduction/) статью, где рассказывается про список этих API.
-
-# Поддержка браузеров
-
-На момент написания статьи (2022 год) полноценная поддержка этого API доступна лишь в браузерах на базе Chromium. Полную таблицу можно посмотреть на сайте [Can I Use](https://caniuse.com/web-serial).
-
-На Android поддержка может быть осуществлена на базе [WebUSB API](https://wicg.github.io/webusb/) и [полифилла Serial API](https://github.com/google/web-serial-polyfill).
-
-# Краткий экскурс про UART
-
-Перед работой с последовательным портом, неплохо было бы знать основы протокола передачи данных UART, если вы с ним уже знакомы, можете пропустить эту часть.
-
-**UART** - расшифровывается как (Universal Asynchronous Receiver Transmitter) - универсальный асинхронный приемопередатчик, который определяет протокол для приема и передачи данных между двумя устройствами. **Универсальность** означает, что мы можем настраивать параметры, включая скорость передачи данных. **Асинхронность** же означает, что у нас нет синхронизирующего сигнала между передатчиком и приёмником. Существует также и синхронная версия передачи данных с общим тактовым сигналом, которая может передавать данные намного быстрее, но она используется редко. Для связи двух устройств используются лишь две линии, которые обозначаются как RX (**receiver**) и TX (**transmitter**).
-
-<figure>
-
-<img alt="Схема подключения двух UART устройств" width="550" height="300" src="/media/uart-connection.jpg" loading="lazy" decoding="async">
-
-<figcaption>Схема подключения двух UART устройств</figcaption>
-
-</figure>
-
-UART передает данные последовательно по одному биту в одном из трех режимов:
-
-* односторонний режим - данные отправляются только в одном направлении, от передатчика к приемнику
-* полудуплексный режим - устройства могут передавать и принимать данные по очереди
-* полнодуплексный режим - устройства могут передавать и принимать данные одновременно
-
-Так как в этом проекте предполагается использование асинхронной версии UART, то соответственно необходимо устанавливать **одинаковую** скорость передачи битов в секунду (`baud rate`, `bps`) на двух устройствах. Наиболее распространенные скорости являются: **4800, 9600, 19.2 К, 57.6К и 115.2К.**
-
-Данные передаются в виде так называемых `пакетов`, где каждый пакет содержит в себе:
-
-* стартовый и стоповый биты - стартовый бит сигнализирует о поступлении битов данных, стоповый соответственно о конце данных.
-* биты данных - пользовательские данные, которые поступают сразу после стартового бита, может содержаться от 5 до 8 битов.
-* бит четности - необязательный бит, который идет после битов данных и перед стоповым битом и используется для обнаружения ошибок.
-
-<figure>
-	<img src="/media/uart-packet.jpg" width="700" height="300" alt="Структура UART пакета" format="webp">
-	<figcaption>Структура UART пакета</figcaption>
-</figure>
-
-Я думаю этой информации вполне достаточно для того, чтобы понимать, что из себя представляет UART. Если вы хотите более подробно изучить этот интерфейс, то в интернете существует множество статей на эту тему.
-
-# Преобразователь интерфейсов
-
-Поскольку скорее всего вы будете подключать микроконтроллер к USB порту компьютера, вам необходим некий переводчик между двумя интерфейсами для отправки и получения данных, так как USB и UART совершенно разные протоколы передачи данных. Таких преобразователей существует множество, вот одни из них: [CH340](https://pdf1.alldatasheet.com/datasheet-pdf/view/1132602/WCH/CH340.html), [CP2102](https://pdf1.alldatasheet.com/datasheet-pdf/view/201067/SILABS/CP2102.html) или [FT232](https://pdf1.alldatasheet.com/datasheet-pdf/view/197629/FTDI/FT232BL.html). Если вы используете отладочную плату Arduino UNO, то у вас уже используется один из этих преобразователей на вашей плате.
-
-<figure>
-<img src="/media/arduino-uart-converter.png" width="470" height="320" alt="Преобразователь интерфейсов CH340G на плате Arduino UNO" format="webp"><figcaption>
- Преобразователь интерфейсов CH340G на плате Arduino UNO
- </figcaption>
-</figure>
-
-Если же на вашей отладочной плате не оказалось этого преобразователя интерфейсов, то вы можете приобрести модуль в любом магазине, цена на него обычно не превышает $5.
-
-# Разработка прошивки для микроконтроллера
-
-Как я упомянул ранее, прошивка будет написана для микроконтроллера AVR128DA48. На самом деле неважно какой микроконтроллер вы используете, вам достаточно нужно уметь отправлять и принимать данные используя UART периферию вашего микроконтроллера.
-
-Суть программы будет очень проста: необходимо написать некий ***обработчик команд*** который будет принимать на вход строку (например `led_toggle`) и вызывать необходимую функцию, которая будет выполнять какое-то действие, в данном случае переключать светодиод.
-
-Постановка задачи ясна, теперь рассмотрим реализацию данной программы. Я буду использовать среду разработки MPLAB X IDE и язык C для написания прошивки.
-
-## Необходимые константы
-
-Для начала для всего проекта определим список констант, создав файл `constants.h`:
-
-```c
-#ifndef CONSTANTS_H
-#define	CONSTANTS_H
-
-#define F_CPU           4000000UL
-#define BAUD_RATE       9600
-#define BUFFER_SIZE     20
-#define EOT             0x04
-
-#endif	/* CONSTANTS_H */
-```
-
-* `F_CPU` - тактовая частота микроконтроллера
-* `BAUD_RATE` - скорость передачи данных UART
-* `BUFFER_SIZE` - размер буфера, куда будем складывать поступающие данные
-* `EOT` - End-of-Transmission, ASCII символ конца передачи данных
-
-## Инициализация USART
-
-Создадим заголовочный файл `usart.h` и определим несколько функций для инициализации USART, отправки символа и отправки строки.
-
-```c
-#include "constants.h"
-
-#ifndef USART_H
-#define	USART_H
-#define USART1_BAUD_RATE(BAUD_RATE) ((float)(64 * F_CPU / (16 * (float)BAUD_RATE)) + 0.5)
-
-#include <avr/io.h>
-#include <stdio.h>
-#include <string.h>
-
-void USART1_Initialize(void);
-void USART1_SendChar(char c);
-void USART1_SendString(char *str);
-
-#endif	/* USART_H */
-```
-
-Макрос `USART1_BAUD_RATE` вычисляет значение, которое необходимо записать в регистр `USARTn.BAUD` для установки скорости передачи данных. Формула взята из [документации](https://ww1.microchip.com/downloads/aemDocuments/documents/MCU08/ProductDocuments/DataSheets/AVR128DA28-32-48-64-Data-Sheet-40002183C.pdf) к микроконтроллеру (глава 25.3.2.2.1, таблица 25-1).
-
-Реализуем функцию инициализации USART в файле `usart.c`:
-
-```c
-void USART1_Initialize(void) {
-  /* set baud rate */
-  USART1.BAUD = (uint16_t) (USART1_BAUD_RATE(BAUD_RATE));
-
-  /* set char size in a frame to 8 bit */
-  USART1.CTRLC = USART_CHSIZE0_bm | USART_CHSIZE1_bm;
-
-  /* config pins for TX and RX */
-  PORTC.DIRSET = PIN0_bm;
-  PORTC.DIRCLR = PIN1_bm;
-
-  /* enable reveice complete interrupt */
-  USART1.CTRLA = USART_RXCIE_bm;
-
-  /* enable transmitter and receiver */
-  USART1.CTRLB = USART_TXEN_bm | USART_RXEN_bm;
-}
-```
-
-Для полнодуплексного режима инициализация асинхронной версии USART происходит следующим образом:
-
-* Конфигурация скорости передачи данных путем записывания значения в регистр `USARTn.BAUD`
-* Конфигурация размера `фрейма`, в нашем случае это 8 бит.
-* Конфигурация пина `TX` на выход и пина `RX` на вход.
-* Включение прерывания на то, когда закончился прием данных (когда пришел один пакет).
-* Включение приемника и передатчика.
-
-Теперь, рассмотрим функции отправки данных:
-
-```c
-void USART1_SendChar(char c) {
-  while (!(USART1.STATUS & USART_DREIF_bm));
-
-  USART1.TXDATAL = c;
-}
-
-void USART1_SendString(char *str) {
-  for (size_t i = 0; i < strlen(str); i++) {
-    USART1_SendChar(str[i]);
-  }
-}
-```
-
-Для того чтобы отправить данные, необходимо записать в регистр `USARTn.TXDATAL` один байт, но перед этим нужно убедиться, что предыдущая передача была завершена путем проверки регистра `USARTn.STATUS`. Как указано в документации, бит `DREIF` (Data Register Empty Flag) является установленным, если данные в TX буфере **отсутствуют**. Соответственно можно сделать пустой цикл который будет выполняться пока у нас есть данные в TX буфере.
-
-Функция отправки строки является некой оберткой, которая будет вызывать функцию отправки одного символа.
-
-## Обработчик команд
-
-Как видно из постановки задачи, на вход нам поступает некая строка, которая говорит о том, какое действие должно выполниться.
-
-Определим заголовочный файл `command.h` и напишем туда следующее:
-
-```c
-#ifndef COMMAND_H
-#define	COMMAND_H
-
-#include <avr/io.h>
-#include <string.h>
-
-#define COMMAND_SIZE 5
-#define COMMAND_MAX_NAME_LENGTH 20
-
-struct Command {
-  void *addr;
-  char name[COMMAND_MAX_NAME_LENGTH];
-};
-
-uint8_t command_define(void *fp, char name[COMMAND_MAX_NAME_LENGTH]);
-uint8_t command_process(char *cmd_name);
-void command_list(void);
-
-#endif	/* COMMAND_H */
-```
-
-Для решения этой задачи я предлагаю создавать массив структур, где в каждой структуре будет содержаться указатель на функцию которую нам нужно выполнить, и название самой команды.
-
-* `command_define` будет создавать новую структуру в массиве.
-* `command_process` будет вызывать соответствующую функцию по имени команды.
-* `command_list` будет отправлять по UART информацию о существующих командах.
-
-Реализовать задуманное можно следующим образом создав файл `command.c`:
-
-```c
-#include "command.h"
-#include "usart.h"
-
-struct Command commands[COMMAND_SIZE];
-uint8_t cmd_idx = 0;
-
-uint8_t command_define(void *fp, char name[COMMAND_MAX_NAME_LENGTH]) {
-  size_t name_length = strlen(name);
-  if (name_length > COMMAND_MAX_NAME_LENGTH) {
-    return 0;
-  }
-
-  if (cmd_idx > COMMAND_SIZE) {
-    cmd_idx = 0;
-  }
-
-  struct Command command;
-  command.addr = fp;
-  strcpy(command.name, name);
-  commands[cmd_idx++] = command;
-  return 1;
-}
-
-uint8_t command_process(char *cmd_name) {
-  uint8_t i = 0;
-
-  do {
-    if (strcmp(cmd_name, commands[i].name) == 0) {
-      int (*execute)();
-      execute = commands[i].addr;
-      execute();
-      USART1_SendString("[LOG]: Command completed successfully with code \"0\".\n");
-      USART1_SendChar(EOT);
-      return 0;
-    }
-  } while (i++ < COMMAND_SIZE);
-
-  USART1_SendString("[LOG]: Invalid command name!\n");
-  USART1_SendChar(EOT);
-
-  return 1;
-}
-
-void command_list(void) {
-  USART1_SendString("[LOG]: List of available commands:\n");
-  for (uint8_t i = 0; i < COMMAND_SIZE; i++) {
-    if (commands[i].addr) {
-      USART1_SendChar((i + 1) + '0');
-      USART1_SendString(". ");
-      USART1_SendString(commands[i].name);
-      USART1_SendChar('\n');
-    }
-  }
-}
-```
-
-Важно отметить, что после отправки данных, необходимо отослать символ `EOT`, который будет говорить о том, что передача закончена, это поможет в будущем в разработке веб-приложения.
-
-## Прием данных
-
-Последнее, что необходимо сделать, это принимать команды по USART и отправлять их обработчику. Для этого можно использовать прерывание:
-
-```c
-char buffer[BUFFER_SIZE];
-volatile uint8_t buff_idx = 0;
-
-ISR(USART1_RXC_vect) {
-  if (buff_idx > BUFFER_SIZE) buff_idx = 0;
-  buffer[buff_idx] = USART1.RXDATAL;
-  buff_idx++;
-}
-```
-
-После срабатывания прерывания `USART1_RXC_vect`, в регистре `USART1.RXDATAL` появляются данные (один байт). Этот байт мы должны записать в свой буфер с фиксированным размером. Еще есть другой вариант принятия данных не используя прерывание. Для этого достаточно проверять бит `RXCIF` (USART Receive Complete Interrupt Flag) в регистре `USARTn.STATUS`. Этот бит является установленным, когда в приемном буфере присутствуют данные.
-
-Для того того чтобы обработать входящие команды, в главном цикле можно проверять буфер на наличие символа `\n`, этот символ будет означать конец названия команды:
-
-```c
-while (1) {
-	if (buff_idx >= 1) {
-	  if (buffer[buff_idx - 1] == '\n') {
-	    buffer[buff_idx - 1] = '\0';
-	    command_process(buffer);
-	    buff_idx = 0;
-	  }
-	}
-}
-```
-
-После нахождения этого символа, можно передать буфер обработчику, затем сбросить индекс буфера в ноль. В итоге файл `main.c` будет выглядеть следующим образом:
-
-```c
-#include <avr/io.h>
-#include <avr/interrupt.h>
-#include <string.h>
-#include "constants.h"
-#include "command.h"
-#include "usart.h"
-
-char buffer[BUFFER_SIZE];
-volatile uint8_t buff_idx = 0;
-
-void led_toggle(void);
-void hello_world(void);
-
-ISR(USART1_RXC_vect) {
-  if (buff_idx > BUFFER_SIZE) buff_idx = 0;
-  buffer[buff_idx] = USART1.RXDATAL;
-  buff_idx++;
-}
-
-void MCU_Init_Ports(void) {
-  /* led pin PC6 to output */
-  PORTC.DIRSET = PIN6_bm;
-}
-
-int main(void) {
-  MCU_Init_Ports();
-  USART1_Initialize();
-  sei();
-
-  command_define(led_toggle, "led_toggle");
-  command_define(hello_world, "hello");
-  command_define(command_list, "list");
-
-  while (1) {
-    if (buff_idx >= 1) {
-      if (buffer[buff_idx - 1] == '\n') {
-        buffer[buff_idx - 1] = '\0';
-        command_process(buffer);
-        buff_idx = 0;
-      }
-    }
-  }
-}
-
-void led_toggle(void) {
-  PORTC.OUTTGL = PIN6_bm;
-}
-
-void hello_world(void) {
-  USART1_SendString("Hello world!\n");
-}
-```
-
-Обязательно после инициализации портов микроконтроллера и USART нужно включить глобальные прерывания, вызвав функцию `sei`
-
-С помощью функции `command_define` мы можем определить, по какой переданной команде по USART запускать функцию:
-
-* `led_toggle` будет переключать светодиод.
-* `hello_world` выводить сообщение “Hello world”.
-* `command_list` будет показывать список имеющихся команд.
-
-## Демонстрация работы
-
-Теперь собрав и загрузив прошивку в ваш микроконтроллер, можно проверить работоспособность. Я буду использовать программу `CuteCom` для открытия последовательного порта, вы можете использовать любую другую подобную.
-
-Выберете ваше устройство из списка (в моем случае это `/dev/ttyACM1`) и установите следующие настройки:
-
-* Скорость: **9600** бод
-* Количество битов: **8**
-* Четность: **None**
-* Стоповые биты: **1**
-
-<figure>
-	<img
-		src="/media/uart-connect-settings.png"
-		width="700"
-		height="400"
-		alt="Настройки для открытия последовательного порта"
-		format="webp"
-    fit="fill"
-	>
-	<figcaption>Настройки для открытия последовательного порта</figcaption>
-</figure>
-
-Теперь после открытия порта можно отправлять команды, не забудьте установить возврат каретки как `LF`, т.к наша прошивка распознает окончание команды только по этому символу.
-
-<figure>
-	<img
-		src="/media/webserial-demo-1.png"
-		width="700"
-		height="400"
-		alt="Пример отправки команды “hello”"
-		format="webp"
-    fit="fill"
-	>
-	<figcaption>Пример отправки команды “hello”</figcaption>
-</figure>
-
-# Разработка веб-приложения
-
-Веб-приложение будет состоять всего из нескольких элементов: поле для ввода, куда мы сможем писать наши команды, кнопки для открытия и закрытия последовательного порта, статус соединения. Готовый вариант можно посмотреть [здесь](https://web-serial-example.netlify.app/).
-
-## Создание разметки HTML и стилей
-
-Разметка HTML будет выглядеть следующим образом:
-
-```html
-<!DOCTYPE html>
-<html lang="en">
-	<head>
-		<meta charset="UTF-8" />
-		<meta http-equiv="X-UA-Compatible" content="IE=edge" />
-		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
-		<title>Web Serial API Example</title>
-		<link href="./style.css" rel="stylesheet" />
-		<script defer src="./app.js"></script>
-	</head>
-	<body>
-		<div id="app">
-			<div>
-				<button id="connect">Connect</button>
-				<button id="disconnect">Disconnect</button>
-			</div>
-			<form id="terminal_form" action="#">
-				<label for="input">Enter command name:</label><br />
-				<div>
-					<input id="input" name="input" placeholder="e.g led_toggle" type="text" disabled />
-					<button name="send" type="submit" disabled>Send</button>
-				</div>
-			</form>
-			<textarea id="serial_log" placeholder=">" readonly></textarea>
-			<div id="port_info">
-				<div>
-					<p id="status">not connected</p>
-				</div>
-				<div>
-					<span>vendorId: <span id="vendor_id">-</span>&nbsp;|</span>
-					<span>deviceId: <span id="product_id">-</span></span>
-				</div>
-			</div>
-		</div>
-	</body>
-</html>
-```
-
-Добавим немного стилей создав файл `style.css`:
-
-```css
-:root {
-	--border-color: #c9d1d9;
-	--border-color-hover: #6e7681;
-	--font-family: monospace;
-}
-
-*,
-*:before,
-*:after {
-	box-sizing: inherit;
-}
-
-#app {
-	display: flex;
-	flex-direction: column;
-	width: 100%;
-	max-width: 600px;
-	row-gap: 5px;
-}
-
-html,
-body {
-	box-sizing: border-box;
-	font-size: 16px;
-}
-
-body {
-	display: flex;
-	justify-content: center;
-	margin-top: 2rem;
-	font-family: var(--font-family);
-}
-
-p {
-	padding: 0;
-	margin: 5px;
-}
-
-input,
-textarea {
-	font-family: var(--font-family);
-	padding: 5px 15px;
-	border-radius: 4px;
-	width: 100%;
-	border: 1px solid var(--border-color);
-}
-
-textarea {
-	resize: vertical;
-	min-height: 200px;
-	line-height: 1.4;
-	font-size: 16px;
-	outline: none;
-	font-size: 12px;
-}
-
-label {
-	font-size: 14px;
-	font-style: italic;
-}
-
-button {
-	cursor: pointer;
-	background: none;
-	font-family: var(--font-family);
-	border: 1px solid var(--border-color);
-	border-radius: 4px;
-	padding: 5px 15px;
-}
-
-button:hover:not(:disabled) {
-	border: 1px solid var(--border-color-hover);
-}
-
-#terminal_form div {
-	display: flex;
-	justify-content: space-between;
-	gap: 5px;
-	margin-bottom: 5px;
-	margin-top: 5px;
-}
-
-#port_info {
-	display: flex;
-	justify-content: space-between;
-	align-items: center;
-	flex-wrap: wrap;
-	font-size: 14px;
-}
-
-#port_info #status {
-	text-transform: uppercase;
-}
-```
-
-## Создание класса SerialPortHandler
-
-Логика работы с последовательным портом будет реализована в этом классе, который будет небольшой оберткой для удобного использования WebSerial API, он будет иметь всего 5 методов и несколько свойств.
-
-Определим этот класс в файле `app.js`:
-
-```jsx
-class SerialPortHandler {
-	constructor(options, onConnect, onDisconnect) {
-		this.encoder = new TextEncoder();
-		this.decoder = new TextDecoder();
-		this.onConnect = onConnect;
-		this.onDisconnect = onDisconnect;
-		this.options = options;
-		this.port = null;
-		this.isOpened = false;
-		this.#setupListeners();
-	}
-
-	async open() {}
-
-	async close() {}
-
-	async write(data) {}
-
-	async read() {}
-
-	#setupListeners() {}
-}
-```
-
-* [`TextEncoder`](https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder) является классом, который кодирует строку в массив без знаковых 8-ми битных целых чисел [`Uint8Array`](https://webidl.spec.whatwg.org/#idl-Uint8Array).
-* [`TextDecoder`](https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder#examples) наоборот, декодирует в строку. Экземпляры этих классов нам понадобятся, т.к мы будет оперировать данными с типом `Uint8Array`.
-* Функции `onConnect` и `onDisconnect` будут вызываться при подключении или отключении устройства.
-* Свойство [`options`](https://wicg.github.io/serial/#serialoptions-dictionary) содержит необходимые параметры, которые будут использоваться для передачи и приема данных.
-* Свойство [`port`](https://wicg.github.io/serial/#serialport-interface) - объект, который будет содержать методы для работы с портом и информацию об устройстве после установки соединения.
-* Функция `setupListeners` просто будет добавлять обработчики событий.
-
-Далее рассматривается реализация этих методов.
-
-## Открытие последовательного порта
-
-Для открытия последовательного порта для начала необходимо вызвать метод [`requestPort`](https://wicg.github.io/serial/#requestport-method), который откроет специальное окно со списком устройств. Также необходимо, чтобы пользователь сам активировал вызов этого окна, иначе будет ошибка. Это как раз можно сделать по событию нажатия кнопки.
-
-```jsx
-async open() {
-  try {
-    const port = await navigator.serial.requestPort();
-    await port.open(this.options);
-
-    this.port = port;
-    this.isOpened = true;
-
-    return this.port.getInfo();
-  } catch (error) {
-    console.error(error);
-    throw error;
-  }
-}
-```
-
-В функцию `requestPort` в качестве параметра можно передать необязательный параметр фильтр, который ограничит список выбираемых портов в соответствии с USB идентификатором:
-
-```jsx
-const port = await navigator.serial.requestPort({
-	filters: [{ usbVendorId: 0x7522 }],
-});
-```
-
-Список USB идентификаторов можно посмотреть на [этом](https://devicehunt.com/all-usb-vendors) сайте.
-
-<figure>
-	<img
-		src="/media/webserial-connect.png"
-		width="700"
-		height="400"
-		alt="Выбор устройства через специальное окно"
-		format="webp"
-                fit="fill"
-	>
-	<figcaption>Выбор устройства через специальное окно</figcaption>
-</figure>
-
-После того как пользователь выбрал устройство, метод `requestPort` возвращает [`port`](https://wicg.github.io/serial/#serialport-interface), который можно открыть передав туда [параметры](https://wicg.github.io/serial/#serialoptions-dictionary):
-
-* `baudRate` : скорость передачи данных.
-* `dataBits` : количество бит данных во фрейме (7 или 8).
-* `stopBits` : количество стоповых битов в конце пакета (1 или 2).
-* `parity` : режим четности ( `none` , `even` или `odd` ).
-* `bufferSize` : размер буферов чтения и записи, которые должны быть созданы.
-* `flowControl` : режим управления потоком ( `none` или `hardware` ).
-
-Свойство `baudRate` является единственным обязательным параметром, остальные же являются необязательными и имеют [значения по умолчанию](https://wicg.github.io/serial/#serialoptions-dictionary).
-
-В конце наш метод возвращает [информацию](https://wicg.github.io/serial/#dom-serialportinfo) о подключенном устройстве используя метод [`getInfo`](https://wicg.github.io/serial/#dom-serialport-getinfo).
-
-## Чтение данных
-
-Отмечу, что WebSerial API является асинхронным, что позволяет предотвращать блокировку пользовательского интерфейса во время принятия данных.
-
-Еще важно знать, что WebSerial API использует потоки [Stream API](https://streams.spec.whatwg.org/). При потоковой передаче данные разбиваются на `фрагменты` `(chunks)`, это позволяет обрабатывать данные без полного ожидания их поступления.
-
-Получение данных можно реализовать следующим образом:
-
-```jsx
-async read() {
-  while (this.port.readable) {
-    const reader = this.port.readable.getReader();
-    let chunks = '';
-
-    try {
-      while (true) {
-        const { value, done } = await reader.read();
-        const decoded = this.decoder.decode(value);
-
-        chunks += decoded;
-
-        if (done || decoded.includes(EOT)) {
-          console.log('Reading done.');
-          reader.releaseLock();
-          break;
-        }
-      }
-      return chunks;
-    } catch (error) {
-      console.error(error);
-      throw error;
-    } finally {
-      reader.releaseLock();
-    }
-  }
-}
-```
-
-Когда пользователь подключился к устройству, `this.port` будет иметь такие свойства как `writable` и `readable`, которые являются экземплярами классов [WritableStream](https://streams.spec.whatwg.org/#writablestream) и [ReadableStream](https://streams.spec.whatwg.org/#readablestream). Они нам понадобятся для чтения и записи данных.
-
-Внешний цикл `while` предназначен для проверки ошибок, такие как проверка четности. При возникновении фатальной ошибки, свойство `readable` станет `null`.
-
-Метод [`getReader`](https://streams.spec.whatwg.org/#rs-get-reader) создает [читатель](https://streams.spec.whatwg.org/#reader), который даст возможность получать данные фрагментами. Доступный для чтения поток одновременно имеет не более одного читателя, соответственно после этого поток является **[заблокированным](https://streams.spec.whatwg.org/#lock)**, но читатель остается **активным**.
-
-Внутренний цикл `while` читает данные используя метод `read` у читателя. Этот метод возвращает свойство `value`, который имеет данные c типом `UInt8Array`, и свойство `done`, которое станет `true`, если последовательное устройство больше не передает никаких данных. Далее мы декодируем данные в строку и записываем в переменную `chunks`. Так же идет проверка на наличие символа `EOT` (End-of-Transmission), который означает конец передачи данных. Определите этот символ в начале файла `app.js` как глобальную переменную:
-
-```jsx
-var EOT = "\u0004";
-```
-
-После конца приема данных необходимо разблокировать поток, вызвав метод `releaseLock` для того чтобы сделать читателя неактивным.
-
-## Запись данных
-
-Для того чтобы отправить данные в последовательное устройство, необходимо создать [писателя](https://streams.spec.whatwg.org/#writer), который предоставит возможность отправлять фрагменты в записывающий поток:
-
-```jsx
-async write(data) {
-    const writer = this.port.writable.getWriter();
-    const encoded = this.encoder.encode(data);
-    await writer.write(encoded);
-    writer.releaseLock();
-  }
-```
-
-Перед отправкой нужно закодировать вашу строку в данные с типом `UInt8Array`. После создания писателя записывающий поток так же является заблокированным, соответственно после записи необходимо этот поток разблокировать используя тот же метод `releaseLock`.
-
-## Закрытие порта
-
-Для закрытия порта, когда коммуникация с устройством больше не требуется можно использовать метод [`close`](https://wicg.github.io/serial/#dom-serialport-close):
-
-```jsx
-async close() {
-  await this.port.close();
-  this.isOpened = false;
-}
-```
-
-Порт невозможно закрыть когда записывающий или читающий поток является заблокированным.
-
-## Обработка событий
-
-API дает возможность подписываться на события, когда подключается доверенное устройство или когда оно отключается:
-
-```jsx
-#setupListeners() {
-  navigator.serial.addEventListener('connect', this.onConnect);
-  navigator.serial.addEventListener('disconnect', this.onDisconnect);
-}
-```
-
-## Использование созданного класса
-
-Теперь можно написать front-end часть веб-приложения используя наш созданный класс `SerialPortHandler`:
-
-```jsx
-class Application {
-	constructor(root) {
-		if (!("serial" in navigator)) {
-			console.error("Web Serial API is not supported in your browser.");
-			return;
-		}
-
-		this.serialPortHandler = new SerialPortHandler(
-			{ baudRate: 9600 },
-			() => console.log("Device connected."),
-			() => {
-				console.log("Device disconnected.");
-				this.#disconnectHandler();
-			}
-		);
-
-		/**
-		 * DOM Elements
-		 */
-		this.$root = root;
-		this.$connectButton = this.$root.querySelector("#connect");
-		this.$disconnectButton = this.$root.querySelector("#disconnect");
-		this.$terminalForm = this.$root.querySelector("#terminal_form");
-		this.$serialLog = this.$root.querySelector("#serial_log");
-		this.$status = this.$root.querySelector("#status");
-		this.$vendorId = this.$root.querySelector("#vendor_id");
-		this.$productId = this.$root.querySelector("#product_id");
-
-		this.#setupEvents();
-	}
-
-	/**
-	 * Handlers for connecting, disconnecting and sending a command
-	 */
-	#setupEvents() {
-		this.$connectButton.addEventListener("click", this.#connectHandler.bind(this));
-		this.$disconnectButton.addEventListener("click", this.#disconnectHandler.bind(this));
-		this.$terminalForm.addEventListener("submit", this.#submitHandler.bind(this));
-	}
-
-	/**
-	 * Open serial port and notify user of connection status
-	 * @returns {Promise<void>}
-	 */
-	async #connectHandler() {
-		try {
-			if (this.serialPortHandler.isOpened) return;
-			const info = await this.serialPortHandler.open();
-			console.log("Port opened: ", info);
-			this.$terminalForm.elements.input.removeAttribute("disabled");
-			this.$terminalForm.elements.send.removeAttribute("disabled");
-			this.$vendorId.textContent = "0x" + info.usbVendorId.toString(16);
-			this.$productId.textContent = "0x" + info.usbProductId.toString(16);
-			this.$status.textContent = "CONNECTED";
-		} catch (error) {
-			this.$status.textContent = "ERROR";
-		}
-	}
-
-	/**
-	 * Closes the serial port and updates the connection status.
-	 * @returns {Promise<void>}
-	 */
-	async #disconnectHandler() {
-		if (!this.serialPortHandler.isOpened) return;
-		await this.serialPortHandler.close();
-		this.$terminalForm.elements.input.setAttribute("disabled", "true");
-		this.$terminalForm.elements.send.setAttribute("disabled", "true");
-		this.$vendorId.textContent = "-";
-		this.$productId.textContent = "-";
-		this.$status.textContent = "NOT CONNECTED";
-	}
-
-	/**
-	 * Writes data to the serial port and reads the response
-	 * @param {SubmitEvent} e - Form submit event
-	 */
-	async #submitHandler(e) {
-		e.preventDefault();
-		const $form = e.target;
-		const data = $form.elements.input.value;
-		$form.reset();
-		if (this.serialPortHandler.isOpened && data) {
-			this.$serialLog.innerHTML += ">" + data + "\n";
-			await this.serialPortHandler.write(data + "\n");
-			const message = await this.serialPortHandler.read();
-			this.$serialLog.textContent += message.replaceAll(EOT, "");
-			console.log("Message received: \n" + message);
-		}
-		this.$serialLog.scrollTo(0, this.$serialLog.scrollHeight);
-	}
-}
-```
-
-В основном здесь происходит работа с обновлением интерфейса и я думаю не стоит подробно разъяснять логику, отмечу только ключевые моменты:
-
-В конструкторе этого класса можно определить, поддерживает ли браузер WebSerial API, проверив ключ `serial` в объекте `navigator` и если нет, то пишем ошибку в консоль. Объект `this.serialPortHandler` будет являться экземпляром нашего созданного класса `SerialPortHandler`, в качестве аргументов передаем скорость **9600** и функции, которые будут являться обработчиками событий подключения и отключения устройства. Далее ищем необходимые DOM элементы и добавляем на некоторые из них прослушиватель событий.
-
-Метод `#submitHandler` предназначен для отправки команд и принятия результата выполнения команды. При использовании метода `write` обязательно нужно в конце добавить символ `\n`, так программа в микроконтроллере узнает, где заканчивается название команды.
-
-Инициализируйте приложение в конце файла `app.js`:
-
-```js
-new Application(document.getElementById("app"));
-```
-
-## Проверка работы веб-приложения
-
-Теперь можно отсылать команды микроконтроллеру:
-
-<figure>
-	<img
-		src="/media/webserial-demo-2.png"
-		width="550"
-		height="300"
-		alt="Готовый результат веб-приложения"
-		format="webp"
-	>
-	<figcaption>Готовый результат веб-приложения</figcaption>
-</figure>
-
-Ради забавы можно помигать светодиодом:
-
-```js
-const app = new Application(document.getElementById("app"));
-
-setInterval(async () => {
-	if (app.serialPortHandler.isOpened) {
-		await app.serialPortHandler.write("led_toggle" + "\n");
-		const message = await app.serialPortHandler.read();
-		console.log(message);
-	}
-}, 500);
-```
-
-<figure>
-  <img src="/media/webserial-demo-3.gif" loading="lazy" alt="мигание светодиодом" />
-  <figcaption>Мигание светодиодом</figcaption>
-</figure>
-
-# Заключение
-
-Разработав веб-приложение мы убедились, что использование WebSerial API довольно простое. Надеюсь, что эта статья пригодится вам и поможет в разработке вашего проекта.
-
-# Полезные материалы
-
-* [Статус поддержки браузеров Can I use](https://caniuse.com/web-serial)
-* [Документация к WebSerial API](https://wicg.github.io/serial/)
-* [Подробное руководство по Stream API](https://web.dev/streams/)
-* [Список USB идентификаторов](https://devicehunt.com/all-usb-vendors)
-* [Доступ к различным устройствам из браузера](https://web.dev/devices-introduction/)
\ No newline at end of file
diff --git a/src/content/blog/ru/реализация-задержек-в-avr-микроконтроллере.md b/src/content/blog/ru/реализация-задержек-в-avr-микроконтроллере.md
deleted file mode 100644
index 08b264f..0000000
--- a/src/content/blog/ru/реализация-задержек-в-avr-микроконтроллере.md
+++ /dev/null
@@ -1,611 +0,0 @@
----
-author: Сергей Ярков
-title: Реализация задержек в AVR микроконтроллере
-description: Очень часто в программах приходится выполнять задержку. Например
-  при реализации какого либо протокола необходимо в точности выдерживать
-  тайминги, или же необходимо выполнять какую либо логику раз в несколько часов
-  или дней. В этой статье рассмотрены несколько способов реализации задержек.
-tags:
-  - AVR
-  - Tutorial
-  - Microcontrollers
-pubDate: 2023-10-15T16:28:52.587Z
-updatedDate: 2023-10-15T16:28:52.601Z
----
-
-# Способы реализации
-
-Существует два способа как можно реализовать задержку - это использовать аппаратные таймеры микроконтроллера или использовать простой цикл который выполняется определенное количество тактов. Преимущество использования аппаратного таймера микроконтроллера перед обычным программным циклом заключается в неблокирующем выполнении программы за счет того что работа таймера-счетчика не зависит от выполнения основной программы. Но иногда нужно использовать задержку всего в несколько микросекунд, что особо не повлияет на работу программы в некоторых случаях, тогда можно посмотреть в сторону простых циклов. Будет рассмотрен вариант и с длительной задержкой в несколько часов или дней. Программы будут представлены на языке Си и Ассемблера для микроконтроллера AVR ATtiny45V. В качестве основной программы будет моргающий светодиод который переключается раз в 0.5 секунд.
-
-## Используем цикл
-
-Для реализации этого способа задержки для начала нужно посчитать кол-во тактов процессора для выполнения задержки в N секунд и затем сделать цикл. Например для МК с частотой в 8 MHz один такт будет равен `1/8 = 0.125uS`. Значит чтобы рассчитать кол-во тактов например в 0.5 секунд то это будет `(0.5 × 1,000,000) × 8 = 4,000,000` тактов, т.е половина от частоты МК.
-
-Реализация цикла задержки на ассемблере:
-
-```asmatmel
-.MACRO	delay16
-	ldi		delay8_r, LOW(@0 * F_CPU / 4 - 3)			; 1
-	ldi		delay16_r, HIGH(@0 * F_CPU / 4 - 3)		; 1
-	rcall	DELAY16_LOOP													; 3
-.ENDMACRO
-
-DELAY16_LOOP:
-	subi	delay8_r, 1			                      ; 1
-	sbci	delay16_r, 0		                      ; 1
-	brcc	DELAY16_LOOP		                      ; 1 = false, 2 = true
-	ret							                            ; 4
-```
-
-Каждая инструкция в микроконтроллере выполняется за определенное кол-во тактов (комментарии в коде выше). Например инструкция `ldi` выполняется за один такт, а инструкция `brcc` выполняется за два такта - когда условие верно и за один такт когда условие неверно. На кол-во тактов так же влияет и разрядность программного счетчика (см. [AVR Instruction Set](http://ww1.microchip.com/downloads/en/devicedoc/atmel-0856-avr-instruction-set-manual.pdf)).
-
-### Пояснения к программе
-
-В данной реализации используется макрос `delay16` который загружает кол-во тактов в два 8-ми битных регистра которые помечены как младший и старший. Затем вызывается подпрограмма выполнения цикла. Зачем нужно в расчете тактов делить полученное число на 4? Посмотрите на подпрограмму `DELAY16_LOOP` которая выполняет декрементирование 16-ти битного числа, вы увидите что одна итерация цикла занимает 4 такта. От полученного числа отнимаем 3 для компенсации времени.
-
-В итоге максимальная задержка которая может получиться при работе МК в 8 MHz вызвав этот макрос равняется `65535/8 * 4 = 32767.5uS` что не совсем подходит для мигания светодиодом. Что бы сделать задержку дольше, можно использовать 24 бита для хранения кол-ва тактов. Тогда максимальная задержка составит `16,777,216/8 * 5 = 10.48сек`. В итоге получается такая программа с переключающимся светодиодом раз в 0.5 секунд:
-
-```asmatmel
-.EQU	F_CPU			      = 8 ; MHz
-
-.DEF	t1			        = r16
-.DEF	t2			        = r17
-.DEF	delay24_r		    = r18
-.DEF	delay16_r		    = r19
-.DEF	delay8_r		    = r20
-
-.EQU	LED_DDR			    = DDRB
-.EQU	LED_PORT		    = PORTB
-.EQU	LED_PIN_DATA		= PINB
-.EQU	LED_PIN			    = PB0
-
-.MACRO	delay24
-    ldi		delay8_r, LOW(@0 * F_CPU / 5 - 3)
-    ldi		delay16_r, HIGH(@0 * F_CPU / 5 - 3)
-    ldi		delay24_r, BYTE3(@0 * F_CPU / 5 - 3)
-    rcall	DELAY24_LOOP
-.ENDMACRO
-
-.CSEG
-
-.ORG 	0x00
-    rjmp		RESET_vect
-
-RESET_vect:
-    ldi		t1, LOW(RAMEND)
-    out		SPL, t1
-
-INIT:
-    ldi		t1, (1<<LED_PIN)
-    out		LED_DDR, t1
-    clr		t1
-    out		LED_PORT, t1
-
-LOOP:
-    nop
-    delay24	500000
-    nop
-    rcall	LED_TOGGLE
-    rjmp	LOOP
-
-LED_TOGGLE:
-    push	t1
-    push	t2
-    in		t1, LED_PIN_DATA
-    ldi		t2, (1<<LED_PIN)
-    eor		t1, t2
-    out		LED_PORT, t1
-    pop		t2
-    pop		t1
-    ret
-
-DELAY24_LOOP:
-    subi	delay8_r, 1
-    sbci	delay16_r, 0
-    sbci	delay24_r, 0
-    brcc	DELAY24_LOOP
-    ret
-```
-
-Выполнить компиляцию:
-
-```bash
-avrasm2 -fI ./main.asm
-```
-
-Если использовать 32 бита для хранения кол-ва тактов то максимальная задержка уже составит 3221 секунда! Также вместо регистров общего назначения можно использовать ячейки, определенные в оперативной памяти (SRAM).
-
-Чтобы проверить точно ли выполняется задержка, воспользуемся симулятором который встроен в IDE MPLAB X. Перед этим необходимо настроить частоту работы МК в конфигурации проекта:
-
-<figure>
-	<img src="/media/mplabx-ide-sim-option.png" alt="Выбор частоты выполнения инструкций для симулятора">
-	<figcaption>Выбор частоты выполнения инструкций для симулятора</figcaption>
-</figure>
-
-Установим точки останова на холостые операции `nop` до и после вызова макроса и выполним отладку:
-
-![Отладка программы](/media/screen-1.png)
-
-До вызова инструкции `nop` прошло 8 тактов или 1 микросекунда. Очищаем Stopwatch и нажимаем кнопку продолжения программы (F5):
-
-![Отладка программы](/media/screen-2.png)
-
-Можно видеть что после выхода из подпрограммы `DELAY24_LOOP` прошло ровно 500 миллисекунд.
-
-Для языка Си все будет довольно просто. Библиотека [AVR Libc](https://www.nongnu.org/avr-libc/) поставляется с набором утилит которые упрощают программирование. Поэтому нам достаточно указать частоту МК и вызвать определенную функцию. Эта функция как раз из рассчитает нужное кол-во тактов процессора и выполнит цикл.
-
-Код основной программы на языке Си:
-
-```c
-#define F_CPU 8000000
-
-#include <avr/io.h>
-#include <util/delay.h>
-
-#define PIN_LED PB0
-
-int main(void) {
-  DDRB |= _BV(PIN_LED);
-  PORTB = 0x00;
-  for(;;) {
-    _delay_ms(500);
-    PORTB ^= _BV(PIN_LED);
-  }
-  return 0;
-}
-```
-
-Выполнить компиляцию:
-
-```c
-avr-gcc -Wall -mmcu=attiny45 -Os main.c
-avr-objcopy -j .text -j .data -O ihex a.out main.hex
-```
-
-## Используем таймеры
-
-Что если программе не нужно затрачивать процессорное время на выполнение цикла задержки? Как отмечалось ранее работа таймера-счетчика не зависит от выполнения программы. Счетчик может инкрементироваться хоть раз в секунду при работе процессора с частотой в 8MHz. Существует несколько способов как сделать задержку используя 8-ми или 16-ти битные таймеры. Я опишу некоторые из них.
-
-### 8-ми битный таймер с предделителем 16384
-
-Для микроконтроллера ATtiny45V имеются только 8-ми битные таймеры, причем у одного из них (TIMER1) имеется делитель частоты на 16384 что очень удобно:
-
-<figure>
-	<img src="/media/screen-3.png" alt="Таблица выбора предделителя для таймера-счетчика 1">
-	<figcaption>Таблица выбора предделителя для таймера-счетчика 1</figcaption>
-</figure>
-
-Будем использовать таймер в CTC (Clear on Timer Compare match) режиме. Итоговая частота работы таймера-счетчика будет равна: `8MHz/16384 = 488.28Hz`. Один тик таймера будет равняться `1/488.28 = 2048uS`. Значит для 0.5 секунд значение счетчика будет равняться `0.5×488.38 = 244.14` тиков что достаточно для 8-бит. Будем записывать число в регистр сравнения `OCRn` и генерировать прерывание при совпадении.
-
-Программа на ассемблере:
-
-```asmatmel
-.DEF	t1			      = r16
-.DEF	t2			      = r17
-
-.EQU	LED_DDR			  = DDRB
-.EQU	LED_PORT		  = PORTB
-.EQU	LED_PIN_DATA	= PINB
-.EQU	LED_PIN			  = PB0
-
-.CSEG
-
-.ORG 	0x00
-    rjmp	RESET_vect
-
-.ORG	0x03
-    rjmp	TIMER1_COMPA
-
-RESET_vect:
-    ldi		t1, LOW(RAMEND)
-    out		SPL, t1
-
-INIT:
-    ldi		t1, (1<<LED_PIN)
-    out		DDRB, t1
-    clr		t1
-    out		LED_PORT, t1
-
-    ; ========= Setup 8-bit timer-1 in CTC mode with 16384 prescaler =============
-    ; CPU Clock Freq = 8MHz
-    ; Freq(t) = 8MHz / 16384 = 488.28125 Hz
-    ; Tick = 1 / Freq(t) = 1 / 488.28125 = 2048uS (0.002048 sec)
-    ; Ticks = 0.5 sec / 0.002048 sec = 244
-    ; ============================================================================
-    ldi		t1, (1<<CTC1) | (1<<CS13) | (1<<CS12) | (1<<CS11) | (1<<CS10)
-    out		TCCR1, t1							    ; setup timer
-    clr 	t1								        ; clear timer counter register
-    out		TCNT1, t1
-    ldi		t1, 244								    ; 0.5 sec
-    out		OCR1A, t1
-    out 	OCR1C, t1							    ; for clearing timer on compare match
-    ldi		t1, (1<<OCIE1A)						; enable output compare A interrupt
-    out		TIMSK, t1
-
-    sei
-
-LOOP:
-    nop
-    rjmp	LOOP
-
-LED_TOGGLE:
-    push	t1
-    push	t2
-    in		t1, LED_PIN_DATA
-    ldi		t2, (1<<LED_PIN)
-    eor		t1, t2
-    out		LED_PORT, t1
-    pop		t2
-    pop		t1
-    ret
-
-TIMER1_COMPA:
-    push	t1
-    in		t1, SREG
-    rcall	LED_TOGGLE
-    out		SREG, t1
-    pop		t1
-    reti
-```
-
-Программа на языке Си:
-
-```c
-#define F_CPU 8000000
-
-#include <avr/interrupt.h>
-#include <avr/io.h>
-
-#define LED_DDR DDRB
-#define LED_PORT PORTB
-#define LED_PIN_DATA PINB
-#define LED_PIN PB0
-
-/*
- * Timer Counter 1
- * Mode: CTC
- * Prescaler: 16384
- */
-void setup_tc1(void) {
-  TCCR1 |= _BV(CTC1) | _BV(CS13) | _BV(CS12) | _BV(CS11) | _BV(CS10);
-  TCNT1 = 0x00;
-  OCR1A = 244;
-  OCR1C = 244;
-  TIMSK |= _BV(OCIE1A);
-}
-
-void setup_ports(void) {
-  DDRB |= _BV(LED_PIN);
-  PORTB = 0x00;
-}
-
-/*
- * Interrupt every 0.5 sec
- */
-ISR(TIMER1_COMPA_vect) {
-  LED_PORT ^= _BV(LED_PIN);
-}
-
-void system_init(void) {
-  setup_ports();
-  setup_tc1();
-  sei();
-}
-
-int main(void) {
-  system_init();
-  for (;;) {
-    asm("nop");
-  }
-  return 0;
-}
-```
-
-### 8-ми битный таймер с предделителем 1024
-
-Что если доступен предделитель частоты только на 1024? Тогда регистр для сравнения `OCRn` будет равняться 3906, что не подходит для 8-ми битного регистра. Как вариант можно считать количество переполнений таймера. `3906.25/255 = 15` переполнений.
-
-Программа на ассемблере:
-
-```asmatmel
-.DEF	t1 			        = r16
-.DEF	t2 			        = r17
-.DEF	tc1_ovf_cnt		  = r18
-
-.EQU	LED_DDR			    = DDRB
-.EQU	LED_PORT		    = PORTB
-.EQU	LED_PIN_DATA		= PINB
-.EQU	LED_PIN			    = PB0
-
-.EQU	TC1_OVF_COMPARE_VAL 	= 15
-
-.CSEG
-
-.ORG 	0x00
-    rjmp		RESET_vect
-
-.ORG	0x04
-    rjmp		TIMER1_OVF
-
-RESET_vect:
-    ldi		t1, LOW(RAMEND)
-    out		SPL, t1
-
-INIT:
-    ldi		t1, (1<<LED_PIN)
-    out		DDRB, t1
-    clr		t1
-    out		LED_PORT, t1
-
-    ; ========= Setup 8-bit timer-1 in Normal mode with 1024 prescaler =======================
-    ; CPU Clock Freq = 8MHz
-    ; Freq(t) = 8MHz / 1024 = 7812.5 Hz
-    ; Tick = 1 / Freq(t) = 1 / 7812.5 = 128uS (0.000128 sec)
-    ; Ticks = 0.5 sec / 0.000128 sec = 3906.25
-		; Overflows count = 3906 / 255 = 15
-    ; ======================================================================================
-    ldi		t1, (1<<CS13) | (1<<CS11) | (1<<CS10)
-    out		TCCR1, t1						; setup timer
-    clr 	t1							    ; clear timer counter register
-    out		TCNT1, t1
-    ldi		t1, (1<<TOIE1)			; enable overflow interrupt
-    out		TIMSK, t1
-    sei
-
-LOOP:
-    nop
-    rjmp	LOOP
-
-LED_TOGGLE:
-    push	t1
-    push	t2
-    in		t1, LED_PIN_DATA
-    ldi		t2, (1<<LED_PIN)
-    eor		t1, t2
-    out		LED_PORT, t1
-    pop		t2
-    pop		t1
-    ret
-
-TIMER1_OVF:
-    push	t1
-    in		t1, SREG
-    inc		tc1_ovf_cnt
-    cpi		tc1_ovf_cnt, TC1_OVF_COMPARE_VAL
-    brne	PC+3
-    rcall	LED_TOGGLE
-    clr		tc1_ovf_cnt						; clear timer overflow counter register
-    out		SREG, t1
-    pop		t1
-    reti
-```
-
-Программа на языке Си:
-
-```c
-#define F_CPU 8000000
-
-#include <avr/interrupt.h>
-#include <avr/io.h>
-
-#define TC1_OVF_COMPARE_VAL 15
-
-#define LED_DDR DDRB
-#define LED_PORT PORTB
-#define LED_PIN_DATA PINB
-#define LED_PIN PB0
-
-static volatile uint8_t tc1_ovf_cnt = 0;
-
-/*
- * Timer Counter 1
- * Mode: Normal
- * Prescaler: 1024
- */
-void setup_tc1(void) {
-  TCCR1 |= _BV(CS13) | _BV(CS11) | _BV(CS10);
-  TCNT1 = 0x00;
-  TIMSK |= _BV(TOIE1);
-}
-
-void setup_ports(void) {
-  DDRB |= _BV(LED_PIN);
-  PORTB = 0x00;
-}
-
-ISR(TIMER1_OVF_vect) {
-  tc1_ovf_cnt++;
-  if (tc1_ovf_cnt == TC1_OVF_COMPARE_VAL) {
-    LED_PORT ^= _BV(LED_PIN);
-    tc1_ovf_cnt = 0;
-  }
-}
-
-void system_init(void) {
-  setup_ports();
-  setup_tc1();
-  sei();
-}
-
-int main(void) {
-  system_init();
-  for (;;) {
-    asm("nop");
-  }
-  return 0;
-}
-```
-
-### Длительная задержка
-
-Бывают случаи когда нужно выполнять какую либо логику раз в несколько часов или дней. Решением является завести глобальную переменную где будем хранить количество прошедших секунд с момента начала отсчета таймера, а в прерывании переполнения таймера будем уже сравнивать значение счетчика с заданным числом. Следующая программа переключает светодиод раз в 6 часов.
-
-```asmatmel
-.DEF	t1 			        = r16
-.DEF	t2 			        = r17
-.DEF	tc1_ovf_cnt		  = r18
-
-.EQU	LED_DDR			    = DDRB
-.EQU	LED_PORT		    = PORTB
-.EQU	LED_PIN_DATA		= PINB
-.EQU	LED_PIN			    = PB0
-
-.EQU	TC1_OVF_COMPARE_VAL 	= 30
-
-.DSEG
-.ORG	SRAM_START
-
-ellapsed_seconds: .BYTE 2
-
-.CSEG
-
-.ORG 	0x00
-    rjmp		RESET_vect
-
-.ORG	0x04
-    rjmp		TIMER1_OVF
-
-RESET_vect:
-    ldi		t1, LOW(RAMEND)
-    out		SPL, t1
-
-INIT:
-    ldi		t1, (1<<LED_PIN)
-    out		DDRB, t1
-    clr		t1
-    out		LED_PORT, t1
-
-		sts		ellapsed_seconds, t1
-		sts		ellapsed_seconds+1, t1
-
-    ; ========= Setup 8-bit timer-1 in Normal mode with 1024 prescaler =======================
-    ; CPU Clock Freq = 8MHz
-    ; Freq(t) = 8MHz / 1024 = 7812.5 Hz
-    ; Tick = 1 / Freq(t) = 1 / 7812.5 = 128uS (0.000128 sec)
-    ; Ticks = 1 sec / 0.000128 sec = 7812,5
-		; Overflows count = 7812 / 255 = 30
-    ; ======================================================================================
-    ldi		t1, (1<<CS13) | (1<<CS11) | (1<<CS10)
-    out		TCCR1, t1						; setup timer
-    clr 	t1							    ; clear timer counter register
-    out		TCNT1, t1
-    ldi		t1, (1<<TOIE1)			; enable overflow interrupt
-    out		TIMSK, t1
-    sei
-
-LOOP:
-    nop
-    rjmp	LOOP
-
-LED_TOGGLE:
-    push	t1
-    push	t2
-    in		t1, LED_PIN_DATA
-    ldi		t2, (1<<LED_PIN)
-    eor		t1, t2
-    out		LED_PORT, t1
-    pop		t2
-    pop		t1
-    ret
-
-TIMER1_OVF:
-    push	t1
-    in		t1, SREG
-    inc		tc1_ovf_cnt
-    cpi		tc1_ovf_cnt, TC1_OVF_COMPARE_VAL
-    brne	_TIMER1_OVF_EXIT
-
-		clr		tc1_ovf_cnt												; clear timer overflow counter register
-
-		lds 	r24,ellapsed_seconds
-    lds 	r25,ellapsed_seconds+1
-    adiw 	r24, 1
-		sts 	ellapsed_seconds+1, r25
-    sts 	ellapsed_seconds, r24
-
-		cpi		r24, LOW(21600)
-		sbci	r25, HIGH(21600)
-		brne	_TIMER1_OVF_EXIT
-   	rcall	LED_TOGGLE
-		clr		r25
-		sts		ellapsed_seconds, r25							; clear ellapsed seconds
-		sts		ellapsed_seconds+1, r25						; -----------------------
-
-_TIMER1_OVF_EXIT:
-		out		SREG, t1
-    pop		t1
-    reti
-```
-
-Программа на языке Си:
-
-```c
-#include <avr/interrupt.h>
-#include <avr/io.h>
-
-#define TC1_OVF_COMPARE_VAL 30
-
-#define LED_DDR DDRB
-#define LED_PORT PORTB
-#define LED_PIN_DATA PINB
-#define LED_PIN PB0
-
-static volatile uint8_t tc1_ovf_cnt = 0;
-static volatile uint16_t ellapsed_seconds = 0;
-
-/*
- * Timer Counter 1
- * Mode: Normal
- * Prescaler: 1024
- */
-void setup_tc1(void) {
-  TCCR1 |= _BV(CS13) | _BV(CS11) | _BV(CS10);
-  TCNT1 = 0x00;
-  TIMSK |= _BV(TOIE1);
-}
-
-void setup_ports(void) {
-  DDRB |= _BV(LED_PIN);
-  PORTB = 0x00;
-}
-
-ISR(TIMER1_OVF_vect) {
-  tc1_ovf_cnt++;
-
-  if (tc1_ovf_cnt == TC1_OVF_COMPARE_VAL) {
-    tc1_ovf_cnt = 0;
-    ellapsed_seconds++;
-
-    /* Every 6 hours */
-    if (ellapsed_seconds == 21600) {
-      LED_PORT ^= _BV(LED_PIN);
-      ellapsed_seconds = 0;
-    }
-  }
-}
-
-void system_init(void) {
-  setup_ports();
-  setup_tc1();
-  sei();
-}
-
-int main(void) {
-  system_init();
-  for (;;) {
-    asm("nop");
-  }
-  return 0;
-}
-```
-
-# Заключение
-
-Рассмотрены два основных способа реализации задержки используя таймеры и циклы. Выяснили что используя таймер-счетчик можно сделать задержку, которая не будет блокировать основной поток выполнения программы. Для длительных задержек, где необходимо отслеживать прошедшее время в секундах или часах, можно использовать глобальные переменные.
-
-# Полезные материалы
-
-- [AVR Instruction Set](https://ww1.microchip.com/downloads/en/devicedoc/atmel-0856-avr-instruction-set-manual.pdf)
-- [AVR130: Setup and Use of AVR Timers](https://ww1.microchip.com/downloads/en/Appnotes/Atmel-2505-Setup-and-Use-of-AVR-Timers_ApplicationNote_AVR130.pdf)
-- [AVR Delay Loop Calculator](http://darcy.rsgc.on.ca/ACES/TEI4M/AVRdelay.html)
-- [AVR Timer Calculator](https://eleccelerator.com/avr-timer-calculator/)
diff --git a/src/content/blog/ru/управление-и-подключение-сдвигового-регистра-74hc595-к-микрокотнороллеру.md b/src/content/blog/ru/управление-и-подключение-сдвигового-регистра-74hc595-к-микрокотнороллеру.md
deleted file mode 100644
index dc4a9a9..0000000
--- a/src/content/blog/ru/управление-и-подключение-сдвигового-регистра-74hc595-к-микрокотнороллеру.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-draft: true
-author: Сергей Ярков
-title: Управление сдвиговым регистром 74HC595 микроконтроллером
-description: В этом туториале рассматривается то, как управлять сдвиговым
-  регистром 74HC595 в связке с микроконтроллером AVR.
-tags:
-  - AVR
-  - Digital Electronics
-  - Tutorial
-pubDate: 2023-02-14T19:23:55.622Z
-updatedDate: 2023-02-14T19:23:55.646Z
----
-
-...
diff --git a/src/content/skills/en/базы-данных.md b/src/content/skills/en/базы-данных.md
deleted file mode 100644
index de2b4e4..0000000
--- a/src/content/skills/en/базы-данных.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Databases
-list:
-  - icon: postgresql
-    title: PostgreSQL
-  - icon: mongodb
-    title: MongoDB
-  - icon: redis
-    title: Redis
----
diff --git a/src/content/skills/en/инструменты.md b/src/content/skills/en/инструменты.md
deleted file mode 100644
index 92bd83e..0000000
--- a/src/content/skills/en/инструменты.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Tools
-list:
-  - icon: nodejs
-    title: Node.js
-  - icon: docker
-    title: Docker
-  - icon: git-branch
-    title: Git/gitflow
-  - icon: sass
-    title: SASS
-  - icon: webpack
-    title: Webpack
-  - icon: vite
-    title: Vite.js
----
diff --git a/src/content/skills/en/программирование.md b/src/content/skills/en/программирование.md
deleted file mode 100644
index 632a796..0000000
--- a/src/content/skills/en/программирование.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Programming
-list:
-  - icon: nodejs
-    title: Javascript/Typescript
-  - icon: language-c
-    title: C Language
-  - icon: mysql
-    title: SQL
-  - icon: avr
-    title: AVR instruction set
----
diff --git a/src/content/skills/en/фреймворки.md b/src/content/skills/en/фреймворки.md
deleted file mode 100644
index bbc7267..0000000
--- a/src/content/skills/en/фреймворки.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: Frameworks
-list:
-  - icon: adonisjs
-    title: Adonis.js
-  - icon: alpinejs
-    title: Alpine.js
-  - icon: expressjs
-    title: Express.js
-  - icon: socket-io
-    title: Socket.io
-  - icon: astro_filled
-    title: Astro.js
-  - icon: reactjs
-    title: React.js
-  - icon: gatsbyjs
-    title: Gatsby.js
----
diff --git a/src/content/skills/en/языки.md b/src/content/skills/en/языки.md
deleted file mode 100644
index b293f63..0000000
--- a/src/content/skills/en/языки.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Languages
-list:
-  - title: Russian (native)
-  - title: English (B1)
----
diff --git a/src/content/skills/ru/базы-данных.md b/src/content/skills/ru/базы-данных.md
deleted file mode 100644
index 1835e35..0000000
--- a/src/content/skills/ru/базы-данных.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Базы данных
-list:
-  - icon: postgresql
-    title: PostgreSQL
-  - icon: mongodb
-    title: MongoDB
-  - icon: redis
-    title: Redis
----
diff --git a/src/content/skills/ru/инструменты.md b/src/content/skills/ru/инструменты.md
deleted file mode 100644
index 08044a6..0000000
--- a/src/content/skills/ru/инструменты.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Инструменты
-list:
-  - icon: nodejs
-    title: Node.js
-  - icon: docker
-    title: Docker
-  - icon: git-branch
-    title: Git/gitflow
-  - icon: sass
-    title: SASS
-  - icon: webpack
-    title: Webpack
-  - icon: vite
-    title: Vite.js
----
diff --git a/src/content/skills/ru/программирование.md b/src/content/skills/ru/программирование.md
deleted file mode 100644
index 6886a89..0000000
--- a/src/content/skills/ru/программирование.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Программирование
-list:
-  - icon: nodejs
-    title: Javascript/Typescript
-  - icon: language-c
-    title: C Language
-  - icon: mysql
-    title: SQL
-  - icon: avr
-    title: AVR instruction set
----
diff --git a/src/content/skills/ru/фреймворки.md b/src/content/skills/ru/фреймворки.md
deleted file mode 100644
index 965ec67..0000000
--- a/src/content/skills/ru/фреймворки.md
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: Фреймворки
-list:
-  - icon: adonisjs
-    title: Adonis.js
-  - icon: alpinejs
-    title: Alpine.js
-  - icon: expressjs
-    title: Express.js
-  - icon: socket-io
-    title: Socket.io
-  - icon: astro_filled
-    title: Astro.js
-  - icon: reactjs
-    title: React.js
-  - icon: gatsbyjs
-    title: Gatsby.js
----
diff --git a/src/content/skills/ru/языки.md b/src/content/skills/ru/языки.md
deleted file mode 100644
index 5b876d2..0000000
--- a/src/content/skills/ru/языки.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-title: Языки
-list:
-  - title: Русский (родной)
-  - title: Английский (A2)
----
diff --git a/src/content/tags/avr.md b/src/content/tags/avr.md
deleted file mode 100644
index 993e7a7..0000000
--- a/src/content/tags/avr.md
+++ /dev/null
@@ -1,3 +0,0 @@
----
-title: AVR
----
diff --git a/src/content/tags/digital-electronics.md b/src/content/tags/digital-electronics.md
deleted file mode 100644
index ecfc2eb..0000000
--- a/src/content/tags/digital-electronics.md
+++ /dev/null
@@ -1,3 +0,0 @@
----
-title: Digital Electronics
----
diff --git a/src/content/tags/javascript.md b/src/content/tags/javascript.md
deleted file mode 100644
index f81115e..0000000
--- a/src/content/tags/javascript.md
+++ /dev/null
@@ -1,3 +0,0 @@
----
-title: JavaScript
----
diff --git a/src/content/tags/microcontrollers.md b/src/content/tags/microcontrollers.md
deleted file mode 100644
index e02af84..0000000
--- a/src/content/tags/microcontrollers.md
+++ /dev/null
@@ -1,3 +0,0 @@
----
-title: Microcontrollers
----
diff --git a/src/content/tags/tutorial.md b/src/content/tags/tutorial.md
deleted file mode 100644
index bbcd708..0000000
--- a/src/content/tags/tutorial.md
+++ /dev/null
@@ -1,3 +0,0 @@
----
-title: Tutorial
----
diff --git a/src/content/tags/web-development.md b/src/content/tags/web-development.md
deleted file mode 100644
index 58d3084..0000000
--- a/src/content/tags/web-development.md
+++ /dev/null
@@ -1,3 +0,0 @@
----
-title: Web Development
----
diff --git a/src/content/tags/webserial-api.md b/src/content/tags/webserial-api.md
deleted file mode 100644
index 2bd34a6..0000000
--- a/src/content/tags/webserial-api.md
+++ /dev/null
@@ -1,3 +0,0 @@
----
-title: WebSerial API
----
diff --git a/src/graphql/gql.ts b/src/graphql/gql.ts
index b5e57a1..a27632f 100644
--- a/src/graphql/gql.ts
+++ b/src/graphql/gql.ts
@@ -19,6 +19,7 @@ type Documents = {
     "\n\t\tquery RecentArticle {\n\t\t\tarticle {\n\t\t\t\ttranslations(filter: { status: { _eq: \"published\" } }) {\n\t\t\t\t\ttitle\n\t\t\t\t\tcover_image {\n\t\t\t\t\t\tid\n\t\t\t\t\t\ttitle\n\t\t\t\t\t}\n\t\t\t\t\tslug\n\t\t\t\t\tpub_date\n\t\t\t\t\tviews\n\t\t\t\t\tlanguages_code {\n\t\t\t\t\t\tcode\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t": typeof types.RecentArticleDocument,
     "\n\t\tquery Article_translations($slug: String!) {\n\t\t\tarticle_translations(filter: { slug: { _eq: $slug } }) {\n\t\t\t\tid\n\t\t\t\ttitle\n\t\t\t\ttags {\n\t\t\t\t\ttag_id {\n\t\t\t\t\t\ttitle\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tdescription\n\t\t\t\tslug\n\t\t\t\tcontent\n\t\t\t\tauthor {\n\t\t\t\t\tfirst_name\n\t\t\t\t\tlast_name\n\t\t\t\t}\n\t\t\t\tpub_date\n\t\t\t\tviews\n\t\t\t\tlanguages_code {\n\t\t\t\t\tcode\n\t\t\t\t\tname\n\t\t\t\t}\n\t\t\t\tcover_image {\n\t\t\t\t\ttitle\n\t\t\t\t\ttype\n\t\t\t\t\tfilename_disk\n\t\t\t\t}\n\t\t\t\tarticle_id {\n\t\t\t\t\ttranslations {\n\t\t\t\t\t\tslug\n\t\t\t\t\t\tlanguages_code {\n\t\t\t\t\t\t\tcode\n\t\t\t\t\t\t\tname\n\t\t\t\t\t\t}\n\t\t\t\t\t\tpub_date\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t": typeof types.Article_TranslationsDocument,
     "\n\t\tquery AboutMeQuery($pageLang: String!) {\n\t\t\tglobal_translations(filter: { languages_code: { code: { _contains: $pageLang } } }) {\n\t\t\t\tabout\n\t\t\t}\n\t\t}\n\t": typeof types.AboutMeQueryDocument,
+    "\n\t\tquery Project_translations($pageLang: String!) {\n\t\t\tproject_translations(filter: { languages_code: { code: { _contains: $pageLang } } }, sort: [\"-year\"]) {\n\t\t\t\tid\n\t\t\t\ttitle\n\t\t\t\tyear\n\t\t\t\tdescription\n\t\t\t\tsource_url\n\t\t\t\tdemo_url\n\t\t\t\tarticle_url\n\t\t\t\ticon {\n\t\t\t\t\tfilename_disk\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t": typeof types.Project_TranslationsDocument,
     "\n\t\tquery Tag {\n\t\t\ttag {\n\t\t\t\tid\n\t\t\t\ttitle\n\t\t\t}\n\t\t}\n\t": typeof types.TagDocument,
 };
 const documents: Documents = {
@@ -26,6 +27,7 @@ const documents: Documents = {
     "\n\t\tquery RecentArticle {\n\t\t\tarticle {\n\t\t\t\ttranslations(filter: { status: { _eq: \"published\" } }) {\n\t\t\t\t\ttitle\n\t\t\t\t\tcover_image {\n\t\t\t\t\t\tid\n\t\t\t\t\t\ttitle\n\t\t\t\t\t}\n\t\t\t\t\tslug\n\t\t\t\t\tpub_date\n\t\t\t\t\tviews\n\t\t\t\t\tlanguages_code {\n\t\t\t\t\t\tcode\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t": types.RecentArticleDocument,
     "\n\t\tquery Article_translations($slug: String!) {\n\t\t\tarticle_translations(filter: { slug: { _eq: $slug } }) {\n\t\t\t\tid\n\t\t\t\ttitle\n\t\t\t\ttags {\n\t\t\t\t\ttag_id {\n\t\t\t\t\t\ttitle\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tdescription\n\t\t\t\tslug\n\t\t\t\tcontent\n\t\t\t\tauthor {\n\t\t\t\t\tfirst_name\n\t\t\t\t\tlast_name\n\t\t\t\t}\n\t\t\t\tpub_date\n\t\t\t\tviews\n\t\t\t\tlanguages_code {\n\t\t\t\t\tcode\n\t\t\t\t\tname\n\t\t\t\t}\n\t\t\t\tcover_image {\n\t\t\t\t\ttitle\n\t\t\t\t\ttype\n\t\t\t\t\tfilename_disk\n\t\t\t\t}\n\t\t\t\tarticle_id {\n\t\t\t\t\ttranslations {\n\t\t\t\t\t\tslug\n\t\t\t\t\t\tlanguages_code {\n\t\t\t\t\t\t\tcode\n\t\t\t\t\t\t\tname\n\t\t\t\t\t\t}\n\t\t\t\t\t\tpub_date\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t": types.Article_TranslationsDocument,
     "\n\t\tquery AboutMeQuery($pageLang: String!) {\n\t\t\tglobal_translations(filter: { languages_code: { code: { _contains: $pageLang } } }) {\n\t\t\t\tabout\n\t\t\t}\n\t\t}\n\t": types.AboutMeQueryDocument,
+    "\n\t\tquery Project_translations($pageLang: String!) {\n\t\t\tproject_translations(filter: { languages_code: { code: { _contains: $pageLang } } }, sort: [\"-year\"]) {\n\t\t\t\tid\n\t\t\t\ttitle\n\t\t\t\tyear\n\t\t\t\tdescription\n\t\t\t\tsource_url\n\t\t\t\tdemo_url\n\t\t\t\tarticle_url\n\t\t\t\ticon {\n\t\t\t\t\tfilename_disk\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t": types.Project_TranslationsDocument,
     "\n\t\tquery Tag {\n\t\t\ttag {\n\t\t\t\tid\n\t\t\t\ttitle\n\t\t\t}\n\t\t}\n\t": types.TagDocument,
 };
 
@@ -45,6 +47,10 @@ export function graphql(source: "\n\t\tquery Article_translations($slug: String!
  * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
  */
 export function graphql(source: "\n\t\tquery AboutMeQuery($pageLang: String!) {\n\t\t\tglobal_translations(filter: { languages_code: { code: { _contains: $pageLang } } }) {\n\t\t\t\tabout\n\t\t\t}\n\t\t}\n\t"): typeof import('./graphql').AboutMeQueryDocument;
+/**
+ * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
+ */
+export function graphql(source: "\n\t\tquery Project_translations($pageLang: String!) {\n\t\t\tproject_translations(filter: { languages_code: { code: { _contains: $pageLang } } }, sort: [\"-year\"]) {\n\t\t\t\tid\n\t\t\t\ttitle\n\t\t\t\tyear\n\t\t\t\tdescription\n\t\t\t\tsource_url\n\t\t\t\tdemo_url\n\t\t\t\tarticle_url\n\t\t\t\ticon {\n\t\t\t\t\tfilename_disk\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t"): typeof import('./graphql').Project_TranslationsDocument;
 /**
  * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients.
  */
diff --git a/src/graphql/graphql.ts b/src/graphql/graphql.ts
index 38ba2b3..6efb2f8 100644
--- a/src/graphql/graphql.ts
+++ b/src/graphql/graphql.ts
@@ -1810,6 +1810,8 @@ export type Create_Global_Input = {
   email?: InputMaybe<Scalars['String']['input']>;
   github?: InputMaybe<Scalars['String']['input']>;
   id?: InputMaybe<Scalars['ID']['input']>;
+  ntfy_password?: InputMaybe<Scalars['String']['input']>;
+  ntfy_user?: InputMaybe<Scalars['String']['input']>;
   recent_articles_limit?: InputMaybe<Scalars['Int']['input']>;
   telegram?: InputMaybe<Scalars['String']['input']>;
   title?: InputMaybe<Scalars['String']['input']>;
@@ -1852,6 +1854,8 @@ export type Create_Project_Input = {
 };
 
 export type Create_Project_Translations_Input = {
+  article_url?: InputMaybe<Scalars['String']['input']>;
+  demo_url?: InputMaybe<Scalars['String']['input']>;
   description?: InputMaybe<Scalars['String']['input']>;
   icon?: InputMaybe<Create_Directus_Files_Input>;
   id?: InputMaybe<Scalars['ID']['input']>;
@@ -1859,7 +1863,7 @@ export type Create_Project_Translations_Input = {
   project_id?: InputMaybe<Create_Project_Input>;
   source_url?: InputMaybe<Scalars['String']['input']>;
   title?: InputMaybe<Scalars['String']['input']>;
-  year?: InputMaybe<Scalars['String']['input']>;
+  year?: InputMaybe<Scalars['Int']['input']>;
 };
 
 export type Create_Tag_Input = {
@@ -3422,6 +3426,8 @@ export type Global = {
   email?: Maybe<Scalars['String']['output']>;
   github?: Maybe<Scalars['String']['output']>;
   id: Scalars['ID']['output'];
+  ntfy_password?: Maybe<Scalars['String']['output']>;
+  ntfy_user?: Maybe<Scalars['String']['output']>;
   recent_articles_limit?: Maybe<Scalars['Int']['output']>;
   telegram?: Maybe<Scalars['String']['output']>;
   title?: Maybe<Scalars['String']['output']>;
@@ -3446,6 +3452,8 @@ export type Global_Filter = {
   email?: InputMaybe<String_Filter_Operators>;
   github?: InputMaybe<String_Filter_Operators>;
   id?: InputMaybe<Number_Filter_Operators>;
+  ntfy_password?: InputMaybe<String_Filter_Operators>;
+  ntfy_user?: InputMaybe<String_Filter_Operators>;
   recent_articles_limit?: InputMaybe<Number_Filter_Operators>;
   telegram?: InputMaybe<String_Filter_Operators>;
   title?: InputMaybe<String_Filter_Operators>;
@@ -3818,6 +3826,8 @@ export type Project_Mutated = {
 
 export type Project_Translations = {
   __typename?: 'project_translations';
+  article_url?: Maybe<Scalars['String']['output']>;
+  demo_url?: Maybe<Scalars['String']['output']>;
   description?: Maybe<Scalars['String']['output']>;
   icon?: Maybe<Directus_Files>;
   id: Scalars['ID']['output'];
@@ -3825,7 +3835,7 @@ export type Project_Translations = {
   project_id?: Maybe<Project>;
   source_url?: Maybe<Scalars['String']['output']>;
   title?: Maybe<Scalars['String']['output']>;
-  year?: Maybe<Scalars['String']['output']>;
+  year?: Maybe<Scalars['Int']['output']>;
 };
 
 
@@ -3874,6 +3884,8 @@ export type Project_Translations_Aggregated = {
 
 export type Project_Translations_Aggregated_Count = {
   __typename?: 'project_translations_aggregated_count';
+  article_url?: Maybe<Scalars['Int']['output']>;
+  demo_url?: Maybe<Scalars['Int']['output']>;
   description?: Maybe<Scalars['Int']['output']>;
   /** SVG */
   icon?: Maybe<Scalars['Int']['output']>;
@@ -3889,11 +3901,14 @@ export type Project_Translations_Aggregated_Fields = {
   __typename?: 'project_translations_aggregated_fields';
   id?: Maybe<Scalars['Float']['output']>;
   project_id?: Maybe<Scalars['Float']['output']>;
+  year?: Maybe<Scalars['Float']['output']>;
 };
 
 export type Project_Translations_Filter = {
   _and?: InputMaybe<Array<InputMaybe<Project_Translations_Filter>>>;
   _or?: InputMaybe<Array<InputMaybe<Project_Translations_Filter>>>;
+  article_url?: InputMaybe<String_Filter_Operators>;
+  demo_url?: InputMaybe<String_Filter_Operators>;
   description?: InputMaybe<String_Filter_Operators>;
   icon?: InputMaybe<Directus_Files_Filter>;
   id?: InputMaybe<Number_Filter_Operators>;
@@ -3901,7 +3916,7 @@ export type Project_Translations_Filter = {
   project_id?: InputMaybe<Project_Filter>;
   source_url?: InputMaybe<String_Filter_Operators>;
   title?: InputMaybe<String_Filter_Operators>;
-  year?: InputMaybe<String_Filter_Operators>;
+  year?: InputMaybe<Number_Filter_Operators>;
 };
 
 export type Project_Translations_Mutated = {
@@ -3916,6 +3931,8 @@ export type Project_Translations_Quantifier_Filter = {
   _none?: InputMaybe<Project_Translations_Filter>;
   _or?: InputMaybe<Array<InputMaybe<Project_Translations_Filter>>>;
   _some?: InputMaybe<Project_Translations_Filter>;
+  article_url?: InputMaybe<String_Filter_Operators>;
+  demo_url?: InputMaybe<String_Filter_Operators>;
   description?: InputMaybe<String_Filter_Operators>;
   icon?: InputMaybe<Directus_Files_Filter>;
   id?: InputMaybe<Number_Filter_Operators>;
@@ -3923,7 +3940,7 @@ export type Project_Translations_Quantifier_Filter = {
   project_id?: InputMaybe<Project_Filter>;
   source_url?: InputMaybe<String_Filter_Operators>;
   title?: InputMaybe<String_Filter_Operators>;
-  year?: InputMaybe<String_Filter_Operators>;
+  year?: InputMaybe<Number_Filter_Operators>;
 };
 
 export type String_Filter_Operators = {
@@ -4141,6 +4158,8 @@ export type Update_Global_Input = {
   email?: InputMaybe<Scalars['String']['input']>;
   github?: InputMaybe<Scalars['String']['input']>;
   id?: InputMaybe<Scalars['ID']['input']>;
+  ntfy_password?: InputMaybe<Scalars['String']['input']>;
+  ntfy_user?: InputMaybe<Scalars['String']['input']>;
   recent_articles_limit?: InputMaybe<Scalars['Int']['input']>;
   telegram?: InputMaybe<Scalars['String']['input']>;
   title?: InputMaybe<Scalars['String']['input']>;
@@ -4183,6 +4202,8 @@ export type Update_Project_Input = {
 };
 
 export type Update_Project_Translations_Input = {
+  article_url?: InputMaybe<Scalars['String']['input']>;
+  demo_url?: InputMaybe<Scalars['String']['input']>;
   description?: InputMaybe<Scalars['String']['input']>;
   icon?: InputMaybe<Update_Directus_Files_Input>;
   id?: InputMaybe<Scalars['ID']['input']>;
@@ -4190,7 +4211,7 @@ export type Update_Project_Translations_Input = {
   project_id?: InputMaybe<Update_Project_Input>;
   source_url?: InputMaybe<Scalars['String']['input']>;
   title?: InputMaybe<Scalars['String']['input']>;
-  year?: InputMaybe<Scalars['String']['input']>;
+  year?: InputMaybe<Scalars['Int']['input']>;
 };
 
 export type Update_Tag_Input = {
@@ -4240,6 +4261,8 @@ export type Version_Global = {
   email?: Maybe<Scalars['String']['output']>;
   github?: Maybe<Scalars['String']['output']>;
   id?: Maybe<Scalars['ID']['output']>;
+  ntfy_password?: Maybe<Scalars['String']['output']>;
+  ntfy_user?: Maybe<Scalars['String']['output']>;
   recent_articles_limit?: Maybe<Scalars['Int']['output']>;
   telegram?: Maybe<Scalars['String']['output']>;
   title?: Maybe<Scalars['String']['output']>;
@@ -4288,6 +4311,8 @@ export type Version_Project = {
 
 export type Version_Project_Translations = {
   __typename?: 'version_project_translations';
+  article_url?: Maybe<Scalars['String']['output']>;
+  demo_url?: Maybe<Scalars['String']['output']>;
   description?: Maybe<Scalars['String']['output']>;
   icon?: Maybe<Scalars['JSON']['output']>;
   id?: Maybe<Scalars['ID']['output']>;
@@ -4295,7 +4320,7 @@ export type Version_Project_Translations = {
   project_id?: Maybe<Scalars['JSON']['output']>;
   source_url?: Maybe<Scalars['String']['output']>;
   title?: Maybe<Scalars['String']['output']>;
-  year?: Maybe<Scalars['String']['output']>;
+  year?: Maybe<Scalars['Int']['output']>;
 };
 
 export type Version_Tag = {
@@ -4328,6 +4353,13 @@ export type AboutMeQueryQueryVariables = Exact<{
 
 export type AboutMeQueryQuery = { __typename?: 'Query', global_translations: Array<{ __typename?: 'global_translations', about?: string | null }> };
 
+export type Project_TranslationsQueryVariables = Exact<{
+  pageLang: Scalars['String']['input'];
+}>;
+
+
+export type Project_TranslationsQuery = { __typename?: 'Query', project_translations: Array<{ __typename?: 'project_translations', id: string, title?: string | null, year?: number | null, description?: string | null, source_url?: string | null, demo_url?: string | null, article_url?: string | null, icon?: { __typename?: 'directus_files', filename_disk?: string | null } | null }> };
+
 export type TagQueryVariables = Exact<{ [key: string]: never; }>;
 
 
@@ -4441,6 +4473,25 @@ export const AboutMeQueryDocument = new TypedDocumentString(`
   }
 }
     `) as unknown as TypedDocumentString<AboutMeQueryQuery, AboutMeQueryQueryVariables>;
+export const Project_TranslationsDocument = new TypedDocumentString(`
+    query Project_translations($pageLang: String!) {
+  project_translations(
+    filter: {languages_code: {code: {_contains: $pageLang}}}
+    sort: ["-year"]
+  ) {
+    id
+    title
+    year
+    description
+    source_url
+    demo_url
+    article_url
+    icon {
+      filename_disk
+    }
+  }
+}
+    `) as unknown as TypedDocumentString<Project_TranslationsQuery, Project_TranslationsQueryVariables>;
 export const TagDocument = new TypedDocumentString(`
     query Tag {
   tag {
diff --git a/src/queries/index.ts b/src/queries/index.ts
index ba16584..35696f1 100644
--- a/src/queries/index.ts
+++ b/src/queries/index.ts
@@ -1,2 +1,4 @@
 export * from "./tag";
 export * from "./article";
+export * from "./project";
+export * from "./global";
diff --git a/src/queries/project.ts b/src/queries/project.ts
new file mode 100644
index 0000000..45852a7
--- /dev/null
+++ b/src/queries/project.ts
@@ -0,0 +1,27 @@
+import { graphql } from "../graphql";
+import execute from "../graphql/execute";
+
+export async function getProjectList(pageLang: string) {
+	const ProjectTranslationsQuery = graphql(`
+		query Project_translations($pageLang: String!) {
+			project_translations(filter: { languages_code: { code: { _contains: $pageLang } } }, sort: ["-year"]) {
+				id
+				title
+				year
+				description
+				source_url
+				demo_url
+				article_url
+				icon {
+					filename_disk
+				}
+			}
+		}
+	`);
+
+	const result = await execute(ProjectTranslationsQuery, { pageLang });
+
+	if (!result.data || result.data.project_translations.length === 0) return [];
+
+	return result.data.project_translations;
+}
diff --git a/src/styles/global.scss b/src/styles/global.scss
index 4c55fd9..5f9dc6e 100644
--- a/src/styles/global.scss
+++ b/src/styles/global.scss
@@ -24,6 +24,10 @@ body {
 	fill: var(--icon-primary);
 }
 
+img[data-icon] {
+	filter: var(--icon-filter);
+}
+
 html {
 	font-size: 16px;
 	font-weight: normal;
diff --git a/src/templates/Projects.astro b/src/templates/Projects.astro
index 5222066..6bca3fd 100644
--- a/src/templates/Projects.astro
+++ b/src/templates/Projects.astro
@@ -1,28 +1,21 @@
 ---
-import { getCollection } from "astro:content";
 import PageLayout from "@layouts/default.astro";
 import ProjectsList from "@components/ProjectsList.astro";
 import ProjectItem from "@components/ProjectItem.astro";
 import PageHeading from "@components/PageHeading.astro";
 import { getLanguageFromURL, useTranslation } from "@i18n/utils";
+import { getProjectList } from "../queries/project";
 
 const t = useTranslation(Astro);
 const pageLang = getLanguageFromURL(Astro.url.pathname);
-const projects = (await getCollection("projects", (e) => e.slug.startsWith(`${pageLang}/`))).sort(
-	(a, b) => b.data.year - a.data.year
-);
+const projects = await getProjectList(pageLang);
 ---
 
-<PageLayout
-	noIndex
-	lang={pageLang}
-	title={t("pageTitle.projects")}
-	description={t("pageDescription.projects")}
->
+<PageLayout noIndex lang={pageLang} title={t("pageTitle.projects")} description={t("pageDescription.projects")}>
 	<PageHeading heading={t("pageTitle.projects")} description={t("pageDescription.projects")} />
 	<section>
 		<ProjectsList>
-			{projects.map((project) => <ProjectItem data={project.data} />)}
+			{projects.map((data) => <ProjectItem data={data} />)}
 		</ProjectsList>
 	</section>
 </PageLayout>