nucleo | ️‍️ Nucleo | State Container library

In general, I think your design could work. The semaphores are signals for the two tasks to do work. And the mutex protects the shared I2C resource.

However, sharing a resource with a mutex can lead to complications. First, your operations tasks are not responsive to new semaphore signals/events while they are waiting for the I2C resource mutex. Second, if the application gets more complex and you add more blocking calls then the design can get into a vicious cycle of blocking, starvation, race conditions, and deadlocks. Your simple design isn't there yet but you're starting down a path.

As an alternative, consider making a third task responsible for handling all I2C communications. The I2C task will wait for a message (in a queue or mailbox). When a message arrives then the I2C task will perform the associated I2C communication. The operations tasks will wait for the semaphore signal/event like they do now. But rather than waiting for the I2C mutex to become available, now the operations tasks will send/post a message to the I2C task. With this design you don't need a mutex to serialize access to the I2C resource because the I2C task's queue/mailbox does the job of serializing the message communication requests from the other tasks. Also in this new design each task blocks at only one place, which is cleaner and allows the operations tasks to be more responsive to the signals/events.

There is a great deal of commonality between STM32F2, STM32F3 and STM32F4 series. Both F3 and F4 are Cortex-M4 and all three series share common peripherals. In some cases you may find pin-multiplexing options differ, or there are certain peripherals available in one part but not the other.

Different parts may have a different number of USARTs, ADCs, DACs etc. And differing number of available GPIOs. So you should check that the peripherals and ports you use are available on the alternate part.

It is really a matter of going through the data sheet and comparing the function, capabilities and pin-out options for the parts. If you are using the STM32Cube you should have few compatibility issue (Cube has other issues but cross-part compatibility is its main purpose).

The clock trees for each part tend to differ, so you will need part specific C runtime start-up code, but that is normally provided by the toolchain.

The STM32 chips are all cortex-m based (a core they purchase from ARM). And so far they all support the cortex-m0 instruction set (armv6-m). You can follow the ST documentation to see what cortex-m core it has to the technical reference manual at arms website infocenter.arm.com and in there it says which architecture (armv6-m armv7-m armv8-m...) and in there you find out about the instruction set and the architecture. You should not start this journey without the minimum documents. The ARM TRM and ARM ARM for the core and architecture. and the REFERENCE manual from ST (not the programmers manual from either them) and the datasheet from ST.

The cortex-ms boot off of a vector table, described in the architectural reference manual (ARM). The first word is loaded into the stack pointer the second is the reset vector and it is defined as requiring the lsbit to be a 1 (indicating this is a thumb function address). And you can read about the rest. To make a minimal example that is good enough.

All of the STM32 chips I have worked with (I have worked with a ton of them) support a user flash based at 0x08000000 and SRAM at 0x20000000, some of the newer firmware that comes with nucleo boards will insist on the proper 0x08000000 address in the vector table (some small percentage also support a faster memory address at 0x00200000). The ARM documentation will say 0x00000000 basically or indicate a VTOR thing but in reality it is generally 0x00000000 as the address that the logic looks for to find the vector table on reset. Various ways to skin this cat but ST chooses to mirror a percentage of the flash to 0x00000000.

So a very simple example to get you started.

Bootstrap, flash.s

Edit.

Looking through your code I think the issue is to do with your API call. I think you are meant to be pointing to port 5000 not 3000 as I see you are mentioning it in your app.js

Original.

I don't really see anything wrong with this as I have written code like this before. The only thing I could think of changing is writing your use effect to include the id as a dependency so that it only runs when there is an id.

Going top-to-bottom, you have your application code which in the end will likely want to talk to some server: resolve DNS name, open a tcp connection etc. This is what LwIP provides - a set of API functions: socket functions, DNS functions and other. For example, when you do a TCP socket connect to a given IP address and port, it decides which out of available network interfaces to use, constructs a frame in form of array of bytes and sends those bytes over that interface. This is where LwIP part ends - it requesting given network interface to output X bytes it provides, as well as consuming any bytes that may arrive on that interface. It doesn't know how exactly to make the bytes "come out", but it knows how to construct the data to send and understands the data you give it.

Going bottom-to-top, you have your modem - LTE, 3G, 2G, doesn't really matter. Modems provide a set of AT commands to talk to them to perform a set of functions: set SIM card PIN, get signal quality, list available operators, select an operator etc., as well as a way to switch it to PPP mode, which also done ATD command. Assuming the modem has been configured properly before, once you switch it to PPP mode it'll be able to send data using PPP protocol and will also "spit out" any data it receives. This is where the modem part ends - when switched to PPP mode, the modem is able to send and receive raw network traffic using PPP protocol. It knows how to output the raw bytes you give it, but it doesn't understand them on a very high level.

Your role is to connect (interface) both parts. Your modem uses PPP to produce and consume network traffic. LwIP has the capability to understand and produce PPP frames.

In case of sending data out, after preparing a PPP frame LwIP is going to call the sio_write function that is expected to send provided bytes to modem that's already in PPP mode. This is the part that you need to fill in. In case of reads sio_read is used and it's your job to fill it in so that it returns bytes that were received from the modem. How you're going to do that - using RTOS and queues for bytes, no RTOS or any other way - doesn't matter. It's what you find more convenient or what fits your overall project structure better. As long as those functions do what they're supposed to, LwIP will be happy to use them.

This interfacing is discussed in more detail here: https://lwip.fandom.com/wiki/PPP#PPP_over_serial. Again, the general concept is that LwIP is just a software library and in the end it'll want to send and receive bytes. Your job is enabling it to do so, by filling in the functions it expects.

If you configure the output to be PUSH/PULL, adding a PULLDOWN resistor will divide the output voltage over the resistor. Do not use PU/PD resistors with PP, because it is always driven and doesn't need a PU/PD.

Try using this:

What you have written does the following:

1. for 500 counts of the timer do nothing
2. after that turn the LED repeatedly on and off (faster than the eye can see) until the timer wraps
3. when the timer wraps (65.536 seconds?) goto (1).

You can't really do this with GPIO_TogglePin because you will call it many many times during the same value of the counter.

Try something like:

Use C# Attirbute to set a theme on Xamarin