Пн янв 18, 2021 20:00:14
Пн янв 18, 2021 20:07:54
void view_flasher_0(){
}
void view_flasher_1(){
}
void view_flasher_2(){
}
void view_flasher_3(){
}
void view_flasher_4(){
}
void view_flasher_5(){
}
typedef void (*pfun_t)(void);
pfun_t rnd_arr[] = {
view_flasher_0,
view_flasher_1,
view_flasher_2,
view_flasher_3,
view_flasher_4,
view_flasher_5,
};
#define MAX_EFFECTS (sizeof(rnd_arr)/sizeof(rnd_arr[0]))
void swap(pfun_t *val1, pfun_t *val2){
pfun_t t = *val1;
*val1 = *val2;
*val2 = t;
}
...................................................................................................
for(int i=0; i<100; i++){ // Перемешиваем
uint8_t a = rand()%MAX_EFFECTS;
uint8_t b = rand()%MAX_EFFECTS;
swap(&rnd_arr[a], &rnd_arr[b]);
}
for(uint8_t i=0; i<MAX_EFFECTS; i++){ // Вывод эффектов
rnd_arr[i]();
}
Вт янв 19, 2021 20:51:06
Вт янв 19, 2021 21:02:29
Вт янв 19, 2021 21:30:47
Вт янв 19, 2021 22:40:27
Ср янв 20, 2021 08:20:16
typedef unsigned char uint8_t;
Ср янв 20, 2021 08:32:34
Сб янв 23, 2021 16:42:09
Ср фев 03, 2021 17:43:23
/* ATtiny 84 */
#include <avr/io.h>
#include <stdint.h>
#include "pins_0.hpp"
int main(void){
//Pin pin; //Ошибка отсутствия аргументов шаблона перед 'pin'
//Pin.as_output(PORTB, PB0);
//Pin.as_output(PB0);
while(1){ }
}
/* ATtiny 84 */
#ifndef PINS_H_
#define PINS_H_
#include <stdint.h>
#include <avr/io.h>
// arbitrarly use PORT as base addres
// произвольно использовать ПОРТ как базовый адрес
enum base {
A = (const uint16_t) &PORTB,
B = (const uint16_t) &PORTB
// C = (const uint16_t) &PORTC,
// D = (const uint16_t) &PORTD
};
template <base b, uint8_t /*...*/all_args>
class Pin {
private:
// Calculate DDR and PIN offsets from PORT
// Рассчитайте смещения DDR и PIN из ПОРТА
static constexpr int8_t dir_offset = &DDRB - &PORTB;
static constexpr int8_t in_offset = &PINB - &PORTB;
// In C++11, constexpr functions can only contain one statement: return.
// В C++11 функции constexpr могут содержать только один оператор: return.
// This forces recursiveness to be used
// Это заставляет использовать рекурсивность
struct recursive {
// Funtion to terminate iteration
// Функция завершения итерации
static constexpr uint8_t bit_mask(){ return 0; }
// Recursive function
// Рекурсивная функция
// Since this function is private, it can only receive the types of "all_args...",
// that is uint8_t
// Поскольку эта функция является частной, она может получать только типы "all_args ...",
// то есть uint8_t
template <typename first_arg_type, typename /*...*/ next_args_types>
static constexpr uint8_t bit_mask(first_arg_type first_arg, next_args_types /*...*/ next_args){
return (1<<first_arg)|bit_mask(next_args/*...*/);
}
};
// This version is valid in C++14 only, constexpr functions have less limitations
// Эта версия действительна только для C++14, функции constexpr имеют меньше ограничений.
struct non_recursive { // нерекурсивный
// put variadic arguments in static constant array for easy access
// поместите вариативные аргументы в статический массив констант для облегчения доступа
static constexpr int arg_count = sizeof/*...*/(all_args);
static constexpr int params[arg_count]={ all_args /*...*/ };
static constexpr uint8_t bit_mask(){
uint8_t mask = 0;
for (unsigned int i = 0; i < arg_count; i++)
mask |= 1<<params[i];
return mask;
}
};
public:
static void set(){
*(volatile uint8_t*)b |= recursive::bit_mask(all_args/*...*/);
}
static void clear(){
*(volatile uint8_t*)b &= ~recursive::bit_mask(all_args/*...*/);
}
static void as_output(){ // как выход
*(volatile uint8_t*) (b + dir_offset) |= recursive::bit_mask(all_args/*...*/);
}
static void as_input(){
*(volatile uint8_t*) (b + dir_offset) &= ~recursive::bit_mask(all_args/*...*/);
}
static void toggle(){ // переключить
*(volatile uint8_t*) (b + in_offset) |= recursive::bit_mask(all_args/*...*/);
}
};
#endif /* PINS_H_ */
Ср фев 03, 2021 18:31:11
template<uint8_t... bits>
consteval uint8_t bit_mask() { return (... | (1 << bits)); }
auto mask = bit_mask<1, 3, 4, 7>(); // 0x9A
Чт фев 04, 2021 00:10:31
/* ATtiny 84 */
#define F_CPU 8000000L
#include <avr/io.h>
#include <stdint.h>
#include <util/delay.h>
enum base {
A = (const uint16_t) &PORTA,
B = (const uint16_t) &PORTB
};
template <base b, uint8_t ... all_args>
class Pin {
private:
static constexpr int8_t dir_offset = &DDRB - &PORTB;
static constexpr int8_t in_offset = &PINB - &PORTB;
struct recursive {
static constexpr uint8_t bit_mask(){ return 0; }
template <typename first_arg_type, typename ... next_args_types>
static constexpr uint8_t bit_mask(first_arg_type first_arg, next_args_types ... next_args){
return (1<<first_arg) | bit_mask(next_args ... );
}
};
struct non_recursive { // нерекурсивный
static constexpr int arg_count = sizeof ... (all_args);
static constexpr int params[arg_count]={ all_args ... };
static constexpr uint8_t bit_mask(){
uint8_t mask = 0;
for (unsigned int i = 0; i < arg_count; i++)
mask |= 1<<params[i];
return mask;
}
};
//----------
public:
static void set(){
*(volatile uint8_t*)b |= recursive::bit_mask(all_args... );
}
static void clear(){
*(volatile uint8_t*)b &= ~recursive::bit_mask(all_args... );
}
static void as_output(){ // как выход
*(volatile uint8_t*)(b + dir_offset) |= recursive::bit_mask(all_args... );
}
static void as_input(){
*(volatile uint8_t*)(b + dir_offset) &= ~recursive::bit_mask(all_args... );
}
static void toggle(){ // переключить
*(volatile uint8_t*)(b + in_offset) |= recursive::bit_mask(all_args... );
}
};
int main(void){
Pin<A, 0> pin1;
pin1.as_output();
pin1.set();
while (1) {
_delay_ms(300);
pin1.toggle();
}
}
Пт мар 19, 2021 18:25:29
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
...
void EXTI0_1_IRQHandler(void)
{
/* USER CODE BEGIN EXTI0_1_IRQn 0 */
/* USER CODE END EXTI0_1_IRQn 0 */
HAL_GPIO_EXTI_IRQHandler(BTN1_Pin);
/* USER CODE BEGIN EXTI0_1_IRQn 1 */
/* USER CODE END EXTI0_1_IRQn 1 */
}
Пт апр 02, 2021 19:09:53
Пт апр 02, 2021 19:55:00
Пт апр 02, 2021 20:48:05
самая старая запись
Пт апр 02, 2021 21:15:03
// Описание структуры, с результатами измерения:
struct {
uint32_t time;
int16_t temperature;
unt16_t pressure;
} Data_t;
// Пишете функцию, которая умеет писать данные в eeprom по заданному адресу
void write_to_eeprom(uint16_t ee_addr, void *data, size_t size);
// Пишете функцию, которая умеет читать данные из eeprom
void read_from_eeprom(uint16_t ee_addr, void *data, size_t size);
// Функция, которая будет искать самую последнюю запись
int16_t find_last_record()
{
int16_t idx = 0;
uint32_t time = 0;
Data_t last_data;
for (int16_t i = 0; i < EEPROM_SIZE / sizeof(Data_t); i++) {
read_from_eeprom(i * sizeof(Data_t), &last_data, sizeof(Data_t));
if (last_data.time != 0xFFFFFFFF && last_data.time > time) {
idx = i;
}
}
return idx;
}
Пт апр 02, 2021 21:26:12
Сб апр 03, 2021 01:36:06
union timech_t{
struct{
uint8_t hours: 5;
uint8_t date: 5;
uint8_t month: 4;
}clock;
uint16_t time;
};
typedef union timech_t timechart_t;
/*пример
timechart_t timestamp;
timestamp.clock.hours = 12;
timestamp.clock.date = 13;
timestamp.clock.month = 4;
//send to EEPROM timestamp.time;
eeprom_write_word(addr, timestamp.time);
//load timestamp from EEPROM
timestamp.time = eeprom_read_word(addr);
теперь можно показать час, дату, месяц.
...timestamp.clock.hours;
...timestamp.clock.date;
...timestamp.clock.month;
*/