#Include
Сам себе игровая консоль: превращаем планшет с нерабочим тачскрином в игровой девайс из 8 кнопок и микроконтроллера
К сожалению, в наше время многие старые, но весьма неплохие по характеристикам гаджеты отправляются напрямую в помойку, и их владельцы не подозревают, что им можно найти применение. Сервер, мультимедийная-станция, да даже просто как TV-приставка — люди в упор не замечают сфер, где старенький планшет мог бы быть полезен. Но как быть, если…
рфайди
#include <MFRC522.h>
#include <SPI.h>
// В настройках можно указать пины, на которых находятся RC522
#define SS_PIN 10
#define RST_PIN 9
MFRC522 mfrc522(SS_PIN, RST_PIN); // Создаем экземпляр объекта RC522
void setup()
{
Serial.begin(9600);
SPI.begin(); // Инициализируем SPI
mfrc522.PCD_Init(); // Инициализируем RC522
Serial.println("RFID ready!");
}
void loop()
{
// Находимся в ожидании RFID-карты
if ( ! mfrc522.PICC_IsNewCardPresent())
{
return;
}
// Cчитываем серийный номер карты
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
// Выводим серийный номер карты
Serial.print(F("Card UID:"));
String cardContent = "";
for (byte i = 0; i < mfrc522.uid.size; i++)
{
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
Serial.print(mfrc522.uid.uidByte[i], HEX);
cardContent.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
cardContent.concat(String(mfrc522.uid.uidByte[i], HEX));
}
Serial.println();
// Перезаписываем значения метки
byte newData[] = {11, 22, 33, 44}; // Новые данные для записи0xDE, 0xAD, 0xBE, 0xEF
byte dataLen = sizeof(newData);
if (mfrc522.MIFARE_Write(1, newData, dataLen))
{
Serial.println(F("Data written successfully"));
}
else
{
Serial.println(F("Error writing data"));
}
// Для того, чтобы проверить, что значения метки были перезаписаны, можем считать данные с метки
byte readData[dataLen];
if (mfrc522.MIFARE_Read(1, readData, &dataLen) && memcmp(newData, readData, dataLen) == 0)
{
Serial.println(F("готово"));
}
else
{
Serial.println(F("нет"));
}
mfrc522.PICC_HaltA(); // Завершаем работу с картой
}
Я пишу полосный вокодер на чистом Си, чтобы тебе не пришлось
#include <complex.h>
double PI;
void _fft(double _Complex buf[], double _Complex out[], int n, int step)
{
if (step < n) {
_fft(out, buf, n, step * 2);
_fft(out + step, buf + step, n, step * 2);
for (int i = 0; i < n; i += 2 * step) {
double _Complex t = cexp(-(__extension__ 1.0iF) * PI * i / n) * out[i + step];
buf[i / 2] = out[i] + t;
buf[(i + n)/2] = out[i] - t;
}
}
}
void fft(double _Complex buf[], int n)
{
double _Complex out[n];
for (int i = 0; i < n; i++) out[i] = buf[i];
_fft(buf, out, n, 1);
}
Небольшая часть кода
Руководство по работе с Normal Edge Decals от Леонардо Иецци
В данном руководстве от художника Леонардо Иецци (Leonardo Iezzi) рассматривается подход с использованием Normal Edge Decals, создание необходимых карт/геометрии и способы их применения.
ПОМОГИТЕ НАЙТИ ОШИБКУ
#include <fio_tmpfile.h>
#include <fiobj_data.h>
#include <fiobj_str.h>
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fio.h>
/* *****************************************************************************
Numbers Type
***************************************************************************** */
typedef struct {
fiobj_object_header_s head;
uint8_t *buffer; /* reader buffer */
union {
FIOBJ parent;
void (*dealloc)(void *); /* buffer deallocation function */
size_t fpos; /* the file reader's position */
} source;
size_t capa; /* total buffer capacity / slice offset */
size_t len; /* length of valid data in buffer */
size_t pos; /* position of reader */
int fd; /* file descriptor (-1 if invalid). */
} fiobj_data_s;
#define obj2io(o) ((fiobj_data_s *)(o))
/* *****************************************************************************
Object required VTable and functions
***************************************************************************** */
#define REQUIRE_MEM(mem) \
do { \
if ((mem) == NULL) { \
perror("FATAL ERROR: fiobj IO couldn't allocate memory"); \
exit(errno); \
} \
} while (0)
static void fiobj_data_copy_buffer(FIOBJ o) {
obj2io(o)->capa = (((obj2io(o)->len) >> 12) + 1) << 12;
void *tmp = fio_malloc(obj2io(o)->capa);
REQUIRE_MEM(tmp);
memcpy(tmp, obj2io(o)->buffer, obj2io(o)->len);
if (obj2io(o)->source.dealloc)
obj2io(o)->source.dealloc(obj2io(o)->buffer);
obj2io(o)->source.dealloc = fio_free;
obj2io(o)->buffer = tmp;
}
static void fiobj_data_copy_parent(FIOBJ o) {
switch (obj2io(obj2io(o)->source.parent)->fd) {
case -1:
obj2io(o)->buffer = fio_malloc(obj2io(o)->len + 1);
memcpy(obj2io(o)->buffer,
obj2io(obj2io(o)->source.parent)->buffer + obj2io(o)->capa,
obj2io(o)->len);
obj2io(o)->buffer[obj2io(o)->len] = 0;
obj2io(o)->capa = obj2io(o)->len;
obj2io(o)->fd = -1;
fiobj_free(obj2io(o)->source.parent);
obj2io(o)->source.dealloc = fio_free;
return;
default:
obj2io(o)->fd = fio_tmpfile();
if (obj2io(o)->fd < 0) {
perror("FATAL ERROR: (fiobj_data) can't create temporary file");
exit(errno);
}
fio_str_info_s data;
size_t pos = 0;
do {
ssize_t written;
data = fiobj_data_pread(obj2io(o)->source.parent, pos + obj2io(o)->capa,
4096);
if (data.len + pos > obj2io(o)->len)
data.len = obj2io(o)->len - pos;
retry_int:
written = write(obj2io(o)->fd, data.data, data.len);
if (written < 0) {
if (errno == EINTR)
goto retry_int;
perror("FATAL ERROR: (fiobj_data) can't write to temporary file");
exit(errno);
}
pos += written;
} while (data.len == 4096);
fiobj_free(obj2io(o)->source.parent);
obj2io(o)->capa = 0;
obj2io(o)->len = pos;
obj2io(o)->source.fpos = obj2io(o)->pos;
obj2io(o)->pos = 0;
obj2io(o)->buffer = NULL;
break;
}
}
static inline void fiobj_data_pre_write(FIOBJ o, uintptr_t length) {
switch (obj2io(o)->fd) {
case -1:
if (obj2io(o)->source.dealloc != fio_free) {
fiobj_data_copy_buffer(o);
}
break;
case -2:
fiobj_data_copy_parent(o);
break;
}
if (obj2io(o)->capa >= obj2io(o)->len + length)
return;
/* add rounded pages (4096) to capacity */
obj2io(o)->capa = (((obj2io(o)->len + length) >> 12) + 1) << 12;
obj2io(o)->buffer = fio_realloc(obj2io(o)->buffer, obj2io(o)->capa);
REQUIRE_MEM(obj2io(o)->buffer);
}
static inline int64_t fiobj_data_get_fd_size(const FIOBJ o) {
struct stat stat;
retry:
if (fstat(obj2io(o)->fd, &stat)) {
if (errno == EINTR)
goto retry;
return -1;
}
return stat.st_size;
}
static FIOBJ fiobj_data_alloc(void *buffer, int fd) {
fiobj_data_s *io = fio_malloc(sizeof(*io));
REQUIRE_MEM(io);
*io = (fiobj_data_s){
.head = {.ref = 1, .type = FIOBJ_T_DATA},
.buffer = buffer,
.fd = fd,
};
return (FIOBJ)io;
}
static void fiobj_data_dealloc(FIOBJ o, void (*task)(FIOBJ, void *),
void *arg) {
switch (obj2io(o)->fd) {
case -1:
if (obj2io(o)->source.dealloc && obj2io(o)->buffer)
obj2io(o)->source.dealloc(obj2io(o)->buffer);
break;
case -2:
fiobj_free(obj2io(o)->source.parent);
break;
default:
close(obj2io(o)->fd);
fio_free(obj2io(o)->buffer);
break;
}
fio_free((void *)o);
(void)task;
(void)arg;
}
ПОМОГИТЕ ОТЛАДИТЬ ПРОГУ
#include <getopt.h>
#include "ask-password-api.h"
#include "build.h"
#include "cryptenroll-fido2.h"
#include "cryptenroll-list.h"
#include "cryptenroll-password.h"
#include "cryptenroll-pkcs11.h"
#include "cryptenroll-recovery.h"
#include "cryptenroll-tpm2.h"
#include "cryptenroll-wipe.h"
#include "cryptenroll.h"
#include "cryptsetup-util.h"
#include "env-util.h"
#include "escape.h"
#include "fileio.h"
#include "libfido2-util.h"
#include "main-func.h"
#include "memory-util.h"
#include "parse-argument.h"
#include "parse-util.h"
#include "path-util.h"
#include "pkcs11-util.h"
#include "pretty-print.h"
#include "string-table.h"
#include "strv.h"
#include "terminal-util.h"
#include "tpm-pcr.h"
#include "tpm2-util.h"
static EnrollType arg_enroll_type = _ENROLL_TYPE_INVALID;
static char *arg_unlock_keyfile = NULL;
static UnlockType arg_unlock_type = UNLOCK_PASSWORD;
static char *arg_unlock_fido2_device = NULL;
static char *arg_pkcs11_token_uri = NULL;
static char *arg_fido2_device = NULL;
static char *arg_tpm2_device = NULL;
static uint32_t arg_tpm2_pcr_mask = UINT32_MAX;
static bool arg_tpm2_pin = false;
static char *arg_tpm2_public_key = NULL;
static uint32_t arg_tpm2_public_key_pcr_mask = UINT32_MAX;
static char *arg_tpm2_signature = NULL;
static char *arg_node = NULL;
static int *arg_wipe_slots = NULL;
static size_t arg_n_wipe_slots = 0;
static WipeScope arg_wipe_slots_scope = WIPE_EXPLICIT;
static unsigned arg_wipe_slots_mask = 0; /* Bitmask of (1U << EnrollType), for wiping all slots of specific types */
static Fido2EnrollFlags arg_fido2_lock_with = FIDO2ENROLL_PIN | FIDO2ENROLL_UP;
#if HAVE_LIBFIDO2
static int arg_fido2_cred_alg = COSE_ES256;
#else
static int arg_fido2_cred_alg = 0;
#endif
assert_cc(sizeof(arg_wipe_slots_mask) * 8 >= _ENROLL_TYPE_MAX);
STATIC_DESTRUCTOR_REGISTER(arg_unlock_keyfile, freep);
STATIC_DESTRUCTOR_REGISTER(arg_unlock_fido2_device, freep);
STATIC_DESTRUCTOR_REGISTER(arg_pkcs11_token_uri, freep);
STATIC_DESTRUCTOR_REGISTER(arg_fido2_device, freep);
STATIC_DESTRUCTOR_REGISTER(arg_tpm2_device, freep);
STATIC_DESTRUCTOR_REGISTER(arg_tpm2_public_key, freep);
STATIC_DESTRUCTOR_REGISTER(arg_tpm2_signature, freep);
STATIC_DESTRUCTOR_REGISTER(arg_node, freep);
STATIC_DESTRUCTOR_REGISTER(arg_wipe_slots, freep);
static bool wipe_requested(void) {
return arg_n_wipe_slots > 0 ||
arg_wipe_slots_scope != WIPE_EXPLICIT ||
arg_wipe_slots_mask != 0;
}
static const char* const enroll_type_table[_ENROLL_TYPE_MAX] = {
[ENROLL_PASSWORD] = "password",
[ENROLL_RECOVERY] = "recovery",
[ENROLL_PKCS11] = "pkcs11",
[ENROLL_FIDO2] = "fido2",
[ENROLL_TPM2] = "tpm2",
};
DEFINE_STRING_TABLE_LOOKUP(enroll_type, EnrollType);
static const char *const luks2_token_type_table[_ENROLL_TYPE_MAX] = {
/* ENROLL_PASSWORD has no entry here, as slots of this type do not have a token in the LUKS2 header */
[ENROLL_RECOVERY] = "systemd-recovery",
[ENROLL_PKCS11] = "systemd-pkcs11",
[ENROLL_FIDO2] = "systemd-fido2",
[ENROLL_TPM2] = "systemd-tpm2",
};
DEFINE_STRING_TABLE_LOOKUP(luks2_token_type, EnrollType);
static int check_for_homed(struct crypt_device *cd) {
int r;
assert_se(cd);
/* Politely refuse operating on homed volumes. The enrolled tokens for the user record and the LUKS2
* volume should not get out of sync. */
for (int token = 0; token < crypt_token_max(CRYPT_LUKS2); token ++) {
r = cryptsetup_get_token_as_json(cd, token, "systemd-homed", NULL);
if (IN_SET(r, -ENOENT, -EINVAL, -EMEDIUMTYPE))
continue;
if (r < 0)
return log_error_errno(r, "Failed to read JSON token data off disk: %m");
return log_error_errno(SYNTHETIC_ERRNO(EHOSTDOWN),
"LUKS2 volume is managed by systemd-homed, please use homectl to enroll tokens.");
}
return 0;
}
static int prepare_luks(
struct crypt_device **ret_cd,
void **ret_volume_key,
size_t *ret_volume_key_size) {
_cleanup_(crypt_freep) struct crypt_device *cd = NULL;
_cleanup_(erase_and_freep) void *vk = NULL;
size_t vks;
int r;
assert(ret_cd);
assert(!ret_volume_key == !ret_volume_key_size);
r = crypt_init(&cd, arg_node);
if (r < 0)
return log_error_errno(r, "Failed to allocate libcryptsetup context: %m");
cryptsetup_enable_logging(cd);
r = crypt_load(cd, CRYPT_LUKS2, NULL);
if (r < 0)
return log_error_errno(r, "Failed to load LUKS2 superblock: %m");
r = check_for_homed(cd);
if (r < 0)
return r;
if (!ret_volume_key) {
*ret_cd = TAKE_PTR(cd);
return 0;
}
r = crypt_get_volume_key_size(cd);
if (r <= 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to determine LUKS volume key size");
vks = (size_t) r;
vk = malloc(vks);
if (r < 0)
return r;
*ret_cd = TAKE_PTR(cd);
*ret_volume_key = TAKE_PTR(vk);
*ret_volume_key_size = vks;
return 0;
}
static int run(int argc, char *argv[]) {
_cleanup_(crypt_freep) struct crypt_device *cd = NULL;
_cleanup_(erase_and_freep) void *vk = NULL;
size_t vks;
int slot, r;
log_show_color(true);
log_parse_environment();
log_open();
r = parse_argv(argc, argv);
if (r <= 0)
return r;
cryptsetup_enable_logging(NULL);
if (arg_enroll_type < 0)
r = prepare_luks(&cd, NULL, NULL); /* No need to unlock device if we don't need the volume key because we don't need to enroll anything */
else
r = prepare_luks(&cd, &vk, &vks);
if (r < 0)
return r;
switch (arg_enroll_type) {
case ENROLL_PASSWORD:
slot = enroll_password(cd, vk, vks);
break;
case ENROLL_RECOVERY:
slot = enroll_recovery(cd, vk, vks);
break;
case ENROLL_PKCS11:
slot = enroll_pkcs11(cd, vk, vks, arg_pkcs11_token_uri);
break;
case ENROLL_FIDO2:
slot = enroll_fido2(cd, vk, vks, arg_fido2_device, arg_fido2_lock_with, arg_fido2_cred_alg);
break;
case ENROLL_TPM2:
slot = enroll_tpm2(cd, vk, vks, arg_tpm2_device, arg_tpm2_pcr_mask, arg_tpm2_public_key, arg_tpm2_public_key_pcr_mask, arg_tpm2_signature, arg_tpm2_pin);
break;
case _ENROLL_TYPE_INVALID:
/* List enrolled slots if we are called without anything to enroll or wipe */
if (!wipe_requested())
return list_enrolled(cd);
/* Only slot wiping selected */
return wipe_slots(cd, arg_wipe_slots, arg_n_wipe_slots, arg_wipe_slots_scope, arg_wipe_slots_mask, -1);
default:
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Operation not implemented yet.");
}
if (slot < 0)
return slot;
/* After we completed enrolling, remove user selected slots */
r = wipe_slots(cd, arg_wipe_slots, arg_n_wipe_slots, arg_wipe_slots_scope, arg_wipe_slots_mask, slot);
if (r < 0)
return r;
return 0;
}
DEFINE_MAIN_FUNCTION(run);
я мёртв внутри
#include <iostream>
#include <iomanip>
#include <locale>
#include "windows.h"
using namespace std;
int main() {
setlocale(0, "RUS");
std::cout << "Вы гуль?\n 1. Да.\n 2. Нет." << std::endl;
int menu, aboba = 1000;
cin >> menu;
system("cls");
switch (menu) {
case 1:
while (aboba > 0) {
cout << setw(25) << aboba << "- 7 = ";
aboba -= 7;
cout << aboba << endl;
Sleep(40);
}
break;
default:
cout << "1000-7?" << endl;
break;
}
system("pause>0");
return 0;
}
Продуктивность
Странную вещь замечаю: иной раз код пишется легко и непринуждённо, от новых задач, до всяких TODO: оставленных до лучших времен, а иной раз над вроде не особо сложной задачей сидишь полдня, а воз и ныне там. От чего зависит, при прочих объективных равных, сложно сказать, какие-то биоритмы что-ли.
Туториал по созданию эффекта сел-шейдинга в Unity
Статьи редакции
Поэтапный рассказ с примерами кода.
Тест
Италик текст. Болд текст. Выделенный текст. Юрл текст. Италик болд текст. Выделенный италик текст. Выделенный болд текст. Выделенный италик болд текст.
Иногда говнокод — это просто говнокод.
POchёm локализация?
Совсем недавно я, на этом сайте, высказался по поводу локализации в играх, недвусмысленно намекнув, что локализация это дело третье, и необходима она тогда, и только тогда, когда ваш проект уже вышел и подбил определенную фанбазу, которая возможно окажет посильную помощь в этом непростом деле (хотя если у вас слишком много ресурсов, как денежных,…