lorc

В случае выделения на стеке или в глобальных переменных - разница очень большая. char* - это просто указатель. Как тут правильно сказали - у вас будет два указателя на один и тот же строковый литерал.

char[] - создание массива на стеке. Соответственно, у вас там будут хранится не два указателя, а два массива. Вы сравниваете их и они очевидно не равны.

Вот пример: https://ideone.com/pIhUvq. Как видите, в одном случае у нас 64-битный указатель, а в другом - массив.

А вот в параметрах функции - действительно, большой разницы нет.

Потому что нельзя изменять вектор, по которому вы итерируете. Вот что пишут про std::vector::erase:

Invalidates iterators and references at or after the point of the erase, including the end() iterator.

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

Допустим, в момент нажатия "стоп" угол колеса alpha, а мы хотим чтобы оно остановилось в угле beta, сделав около пяти оборотов. Тогда, если alpha > beta, то нам нужно провернуть колесо на theta = 360 * 5 + beta - alpha градусов.
Если alpha < beta, то понадобиться например theta = 360 * 6 - beta + alpha градусов.

Итого, мы знаем скорость вращения speed, знаем количество градусов которое нужно пройти - theta. Знаем что в конце скорость должна быть 0. Надо посчитать замедление а.

Пришло время математики. За время t колесо провернется на speed * t - a * t * t /2 градусов. Нам надо чтобы оно провернулось на theta.

Значит, мы имеем уравнение speed * t - a * t * t /2 = theta. Еще мы помним что скорость в конце должна быть равна 0. Значит speed - a * t = 0.

Подставляем, сокращем. Получаем a = speed * speed / ( 2 * theta). Теперь вы знаете замедление, на которое нужно уменьшать скорость каждый цикл.

Только, учтите, что у вас время дискретно поэтому, не налажайте с единицами измерения для t, speed и а.

Собственно, именно это и означает. После клона гит не переключается ни в какую ветку.

Почему так получилось? Потому что HEAD репозитория на удаленном сервере смотрит не в ветку, а в какой-то конкретный коммит.

Нет единого стандарта но то, как хеширутся пароли (и тем более - просто строки).

Например, формат passwd описан в `man 3 crypt`:

The glibc version of this function supports additional encryption algorithms.

If salt is a character string starting with the characters "$id$" followed by a string optionally terminated by "$", then the result has the form:

$id$salt$encrypted

id identifies the encryption method used instead of DES and this then determines how the rest of the password string is interpreted. The following values of id are supported:

ID | Method
─────────────────────────────────────────────────────────
1 | MD5
2a | Blowfish (not in mainline glibc; added in some
| Linux distributions)
5 | SHA-256 (since glibc 2.7)
6 | SHA-512 (since glibc 2.7)

Thus, $5$salt$encrypted and $6$salt$encrypted contain the password encrypted with, respectively, functions based on SHA-256 and SHA-512.

"salt" stands for the up to 16 characters following "$id$" in the salt. The "encrypted" part of the password string is the actual computed password. The size of this string is
fixed:

MD5 | 22 characters
SHA-256 | 43 characters
SHA-512 | 86 characters

The characters in "salt" and "encrypted" are drawn from the set [a-zA-Z0-9./]. In the MD5 and SHA implementations the entire key is significant (instead of only the first 8 bytes
in DES).

Since glibc 2.7, the SHA-256 and SHA-512 implementations support a user-supplied number of hashing rounds, defaulting to 5000. If the "$id$" characters in the salt are followed
by "rounds=xxx$", where xxx is an integer, then the result has the form

$id$rounds=yyy$salt$encrypted

where yyy is the number of hashing rounds actually used. The number of rounds actually used is 1000 if xxx is less than 1000, 999999999 if xxx is greater than 999999999, and is
equal to xxx otherwise.

В других местах формат может быть совершенно другой. Поэтому самый точный ответ - посмотреть исходники того кода, который сгенерировал вам эти строки.

Подозреваю, что должно быть вот так:

void SetNextHandler(Handler* next_handler) {  
        if (next) {
            next->SetNextHandler(next_handler); // <- next, не this
        } else {
            this->next = next_handler;
        }
    }

Иначе у вас бесконечная рекурсия получится.

Но вообще, это не самый оптимальный алгоритм, ибо сложность добавления нового хендлера - O(N), хотя можно было бы сделать O(1), если не важен порядок вызова.

А еще, можно бы завести виртуальную функцию, которая будет занимать только хендлингом. Это сделает код более надежным и позволит избежать Handler::HandleRequest(data); в конце каждого хендлера.

STM32F0 имеет DMA для ADC. Соответственно, все что вам нужно - это правильно настроить эту связку и запустить ADC в непрерывном режиме. ADC будет проводить измерения как можно быстрее, а DMA будет складывать эти измерения в память. Может так оказаться, что для вас это будет даже слишком быстро, ибо ADC в 12битном режиме может выдавать данные с частотой вплоть до мегагерца.