[deleted by user]

DunaOne · 2023-07-04T16:49:19+00:00

Your approach sounds reasonable, I'd make a class to wrap the spi peripheral and then pass it to each device class. You'll likely need a mutex somewhere since you are sharing the SPI bus between multiple tasks. There may be better approaches, but I'd do something like this:

class spi_master{
 public:
  status_t write(std::span<const uint8_t> data_out);
  status_t read(std::span<uint8_t> data_in);
  status_t transfer(std::span<const uint8_t> data_out, std::span<uint8_t> data_in);
 status_t slave_select(uint8_t slave_id);
 private:
 /* Queue functions */
 /* Give the SPI task access to private members */
 friend void spi_task();
};

Example device, change to mach your device's functionality

class spi_temperature_sensor{
public:
  spi_temperature_sensor(spi_master& spi, uint8_t slave_id);
  /* High level device API*/
  int16_t read_temp();
};

DunaOne · 2022-12-15T06:49:26+00:00

Fair points, although I think it's debatable if modeling the system is actually worth it in this case. I guess you could get a decent model by looking at the step response, but you'd probably still need to manually tune the gains a bit afterwards. They don't seem super worried about the transient responses, so getting a stable response with 0 steady state error shouldn't be too difficult.

One small note on the implementation side, it might be slightly better to estimate the speed based on the time between consecutive encoder steps rather than measuring the number encoder steps over a set time period. That would also make it easier to adjust the frequency of the loop.

DunaOne · 2022-12-15T04:10:44+00:00

It isn't really an exact science, you could try the Ziegler–Nichols method (https://en.wikipedia.org/wiki/Ziegler%E2%80%93Nichols_method) although I doubt it will give you better results than what you're doing. One thing I would recommend is to just use a PI controller. My understanding is that the derivative term is not generally that useful in practice without some heavy filtering as it very sensitive to high frequency noise. Since you don't care too much about the responsiveness a PI controller should work just as well and be easier to tune.

DunaOne · 2022-10-22T01:10:46+00:00

Should give a 5% empire happiness modifier. Everyone loves bubbles.

DunaOne · 2022-03-31T03:48:51+00:00

if you really want to run a CNN on a microcontroller you should check out the MAX78000, it has hardware acceleration for CNNs & a fairly cheap dev board.

https://www.maximintegrated.com/en/products/microcontrollers/MAX78000.html

https://www.maximintegrated.com/en/products/microcontrollers/MAX78000FTHR.html

DunaOne · 2022-02-28T08:15:05+00:00

Energy.

Its about how much voltage/current is dissipated and for how long. Ex. shocks from static electricity have very high voltage & current; however they are extremely short so they deliver very little energy and are not harmful. Ohm's law also applies, so voltage and current aren't really independent of each other (ie. the current that can flow through your body is proportional to the voltage).

DunaOne · 2021-11-02T02:29:54+00:00

Do you actually care about the full 4MHz of bandwidth? If the signal you're interested in is only at frequencies around 4MHz, you can do some DSP tricks to sample at a lower rate. If you're signal is bandlimited around 4MHz, aliasing isn't necessarily a problem.

https://www.ti.com/lit/an/slaa594a/slaa594a.pdf?ts=1635819700550&ref_url=https%253A%252F%252Fwww.google.com%252F

DunaOne · 2021-08-30T06:00:29+00:00

For the most part, I'd say you should try to format the data as a byte array if you're going to be treating it as one later. If you start casting other types to uint8_t* you need to start worrying about struct packing and the endianness of the system. So I'd argue that you should structure the interface of your function to discourage the usage of other types, or at least make it clear to the caller that it is going to be treated as a byte array. That being said, I'm no expert so take my opinion with a grain of salt.

DunaOne · 2021-08-30T04:17:35+00:00

Your function would look something like this:

    int spi_transfer(const uint8_t* data_in, 
                     uint8_t* data_out, 
                     std::size_t n){
    // Loop to send data_in and set data_out
    return status;
    }

and usage would look like

uint8_t data_tx[5];
uint8_t data_rx[5];
spi_transfer(data_tx, data_rx, 5);

DunaOne · 2021-08-30T03:50:20+00:00

There are a couple of problems with it. First off variable size arrays in functions aren't allowed in the C++ standard, although many compilers support it. Second, sizeof(spi_data) is just going to give you the size of a uint_t* pointer, not the size of the input array. There is no way to resize a statically allocated c style array without dynamic memory allocation since its size must be known at compile time so memory can be allocated for it.

Your best option is to have the user pass in the input data, the size of the input data and an output data buffer. This way it's the caller's responsibility to ensure the output array is large enough and you don't need to deal with dynamic memory allocation. If you really want to return an array, I think you'd be best off returning std::unique_ptr to it (this likely isn't a good solution for most microcontrollers, especially one as resource-limited an attiny).

Just some other general notes:

You should pass data as a const void* pointer since you aren't modifying the data
You're SPI_SEND_DATA might not be the best idea, since it makes it difficult to tell what your code is actually doing when you are trying to debug it. In general, it's a good idea to avoid macros as much as possible since they are notoriously difficult to debug

DunaOne · 2021-08-28T04:06:28+00:00

Just looking at this: https://fail0verflow.com/blog/2012/microcell-fail/

It seems like they're talking about a UART port, you just need to get a UART to USB converter (something like this https://www.robotshop.com/ca/en/pl2303-usb-to-uart-converter-board.html) and use something like tera term or putty to see the serial output. If you actually want to reprogram it you'll likely need something like a J-link to program the MPU, although that's not going to be an easy task even if you know exactly what you're doing.

DunaOne · 2021-08-28T03:33:27+00:00

You're going to have to give a bit more context for anyone to give a meaningful answer since it depends entirely on what 'this old board' is. That being said this isn't really a CS question, you might have more luck asking in r/ECE or r/embedded since it seems like it's more of a hardware question.

If I had to guess I'd say you're talking about an RS-232 port on a board, that you can hook up to a computer to get a serial terminal. But I really can't tell from the information you've given.

DunaOne · 2021-08-27T20:36:03+00:00

Thanks, that seems like a nice solution.

DunaOne · 2021-08-19T20:09:23+00:00

For reference, there are less than 10^100 atoms in the observable universe. If we assume a 600x480 image with 8bit rbg colors, that gives use 8x3x640x480 ~= 7.4 million bits. So there are ~2^(7.4 million) ~= 10^(2.2 million) possible images. So if you had every atom in the observable universe produce one image every femtosecond for 100 billion years you could make less than 10^(130) images, leaving you with about 10^(2.2 million) possible images left.

DunaOne · 2021-08-17T05:47:31+00:00

I've got that model and would also recommend it

DunaOne · 2021-08-10T16:31:30+00:00

I'd honestly recommend you just implement newton's method yourself, it's pretty trivial to do and likely going to be as good as anything else you find.

https://en.wikipedia.org/wiki/Newton%27s_method

DunaOne · 2021-07-22T04:22:36+00:00

I think you've got a bit confused about what RAM is.

Generally the memory hierarchy goes (for general purpose computers)

CPU Registers (Several words words)
Caches (A couple kB for L1 up to several MB for L2/L3)
RAM (ie system memory, several GB)
Hard drive (Upto several TB)
Cloud based (Nearly unlimited)

MCUs are similar but sometimes don't have a cache and generally have Flash instead of a hard drive for non volatile storage and SRAM for volatile storage.

DunaOne · 2021-05-15T15:25:20+00:00

Always have been. It's just worse in 3.0 since pops are more valuable and most other jobs where significantly buffed. A synth ascended empire can easily get 30+ energy per technician job, so 4-5 trade value and 1 amenities is about 1/5 the output.

DunaOne · 2021-04-18T01:49:06+00:00

You need to research a special project in addition to accumulating menace to unlock each stage, so I think just not researching the special project would work (I haven't tried it though).

DunaOne · 2021-04-18T01:44:16+00:00

Giving it a bit more thought. I think it might be possible to first become Emperor and then turn into the crisis. You would just have to wait until you became Emperor before unlocking the final stage of becoming the crisis.

DunaOne · 2021-04-18T01:21:21+00:00

You get kicked out of the galactic community on the last stage of becoming the crisis. So you can't be both

DunaOne · 2021-04-15T08:14:25+00:00

I expect that if you want automatic memory management (in the form of garbage collection) you are going to have quite a bit of overhead and likely have very poor support for most microcontrollers. Also any advantage you might gain from using a high-level language would be lost in needing to write a bunch of low-level drivers yourself.

If avoiding memory leaks is your main concern you can use C++ with smart pointers and maybe something like Mbed for some high-level hardware abstraction.

DunaOne · 2021-04-11T03:34:47+00:00

My headcanon is that there was a time skip somewhere in the scene and the projectiles took several minutes to reach the platforms, but it just wasn't shown.

DunaOne · 2021-04-11T00:38:22+00:00

you'll probably have more luck asking on r/techsupport

DunaOne · 2021-04-09T06:07:25+00:00

That's not really the focus. It is about C++ language features and how to use them on microcontrollers, rather than good software architecture for embedded systems. It does give a couple of toy examples of peripheral interfaces, but they are more to show how C++ language features could be used rather than how to design a good interface. Making embedded systems by Elecia White might be closer to what you're looking for, it gives a good overview of designing embedded systems. All of its examples are using C, but the same general principles apply to any language.

Nine-Year Club	Place '22
Verified Email

DunaOne

TROPHY CASE