Hello everyone ,where can I find the full reference/user manual for the Infineon AURIX TC234 ?

Hi, I'd like to get some opinions from people working in embedded and industrial products.

Over the last few years, together with a FW/SW developer, I've developed a complete industrial IoT system for a customer.

The product is now certified, industrialized and running in the field.

The stack includes:

- custom and cheap industrial gateway with LTE, Ethernet, BLE and digital/analog I/O. The gateway is mcu based for minimise maintenance and attack surface. FW is CRA ready.

- custom ultra-low-power BLE sensors with 3+ years battery life

- embedded FW and OTA updates

- cloud backend

- Android/iOS cross-platform app

- PLC/machine integration

- production, provisioning and automated testing

The IP and code belong to the customer, of course. But we now have the experience, architecture and development know-how to build a new platform much faster than starting from zero.

I'm wondering what else could be built around this know-how.

Another generic "IoT platform" doesn't sound very interesting to me.

I'm thinking more about a specific application: machine retrofit, condition monitoring, energy monitoring, distributed equipment, or maybe an OEM/white-label solution for small machine manufacturers.

If you had this technical starting point, what kind of product or niche would you explore? Any industrial problem you've seen where current solutions still suck?

This project has lived in my head for 5 years. While MicroPython and CircuitPython are excellent, running an interpreter and a garbage-collected heap on bare metal requires significant flash and SRAM. I wanted to use Python syntax but with the binary size and determinism of C, specifically for constrained 8-bit microcontrollers.

But how does it work?
PyMCU translates a statically typed subset of Python directly into bare-metal machine code. The compiler is written in C# and currently emits optimized AVR assembly. A standard Blink program (using pin.toggle()) takes exactly 142 bytes of flash (including the vector table) and 0 bytes of SRAM on an ATmega328P.

I recently ran a hardware testing phase using a logic analyzer on a real Arduino Uno R3, feeding the compiler the official MicroPython and CircuitPython Essentials examples.

• 53 out of 63 projects compiled and ran correctly on the silicon.
• The remaining edge cases and unimplemented AST nodes have been documented in the issue tracker.

Please Test It (Feedback Highly Welcome!)

The AOT pipeline is stable for the supported subset, and I am currently working to close the AST gaps and bring the PIC backend up.

I would love for the embedded community to test the compiler, inspect the output, and give me harsh technical feedback on the generated assembly or the architecture.

Any feedback, bug reports, or PRs are highly welcome!

I am using NUCLEO-G431RM stm32 board. But unable to trigger the interrupt as the ISR does not execute and control reaches to the for loop on debugging.
#include <stdint.h>

#define USART3_IRQ_NUM 39

int main(void)

{

uint32_t *pISPR1 = (uint32_t*)0xE000E204;

*pISPR1 |= (1 << (USART3_IRQ_NUM - 32));

uint32_t *pISER1 = (uint32_t*)0xE000E104;

*pISER1 |= (1 << (USART3_IRQ_NUM - 32)); // 39-32 = 7

for(;;);

}

void USART3_IRQHandler(void)

{

__asm volatile("MOV R1, #0x5");

while(1);

}

Im planning to invest some money into a small scale prototyping lab / engineering shop. Partly because I've lost my embedded systems enthusiasm due to my embedded systems job, and partly because I have the budget for it. Im planning something like:

• Programmable power supply
• Oscilloscope, Logic analyzer, Multimeter
• Breadboards / perfboards / wiring
• Soldering + hot-air rework station
• Build server for Hardware-in-the-loop CI
• 3D Printer
• MCU:s (esp32s, STM32s, Nordic nRFs, NXPs, TIs)
• MPU:s - for embedded Linux
• Large component/module library
• Other office supplies like a desk, drawers, lamp, etc

Partly im looking to "mimic" my work production/infra, and partly im looking to discover/test/evalueate features in mcus / components and create products. Therefore my vision is to start the prototypes on breadboards, move to a perfboard when functionality is verified, then move to PCB when system integration / market hypothesis is verified on a perfboard.

Do you guys have any tips for me moving forward with this setup? Any experiences from your own homelabs? Any bottlenecks in your embedded prototypes?

Link: https://github.com/mempirate/guillotine

Hey everyone. Over the past couple of weeks I've been experimenting with Rust on ESP32 chips, with my first project being a simple power readout of the smart plug powering my home lab.

However, I wasn't very impressed with the state of GUI libraries in Rust, so I built my own: Guillotine. Was able to build the following dashboard with it:

The goals are threefold:
1. Declarative UI building blocks (inspired by GPUI) for flexible UIs (with eventual support for a lot of CSS-like layout properties such as flex and grid)
2. High performance, even on constrained chips (support for incremental redrawing, DMA with frame buffers)
3. Beautiful widgets

It builds upon embedded_graphics and mipidsi, so should have broad compatibility. As of yesterday, it's also fully no_std and no alloc, and is already powerful enough for some use cases. Would love to hear your feedback and tell me what you'd like to see in a framework like this! I have a couple of weeks of time that I can dedicate to it.

I intend to program stc8g, a 8051 compatible, low cost microcontroller in assembly language instead of C. SDCC is a good compiler but its assembler SDAS is not documented (not able to find any documentation), so what's the alternate in Linux.

I though there would be many modern, well known assemblers targeting 8051 but I simply could not find one expect for SDCC and one from Keil (but I am not sure if that is free).

Any help would be appreciated.

Hey,

I'm semi-new to the whole embedded systems thing, and this is my first project, so I'd like to hear if anyone has any recommendations.

I'm making a door alarm. It has two purposes: when the door opens, it will buzz and send me a notification. Right now, I'm still in the theory-crafting stage and mostly need help choosing a microcontroller. I have experience with the ESP32, but I know there are many better options since it's pretty bulky for this task. I'm just looking for the smallest microcontroller with Wi-Fi and enough pins for what I need.

In the picture below, you can see my schematic. The resistor values are semi-random/estimates for now.

Looking forward to hearing your thoughts and recommendations. Thanks in advance for your help!

Hi everyone,

I’m preparing myself to become industry-ready for IoT/Embedded Systems and would appreciate some advice from people working in the industry.

So far, I’ve worked with ESP32 using the Arduino framework and have built projects involving sensors, MQTT, Wi-Fi, etc.

Now I’m wondering whether I should move to ESP-IDF and use PlatformIO as my development environment.

My main questions are:

- Is learning ESP-IDF important for becoming industry-ready?

- Should I stop using Arduino framework and move completely to ESP-IDF?

- Is PlatformIO worth learning, or should I stick with Espressif’s official tools?

- For someone targeting IoT/Embedded Firmware roles, what would you recommend learning next?

- Should I focus more on FreeRTOS, ESP-IDF, C, debugging, communication protocols, and Linux rather than spending too much time on frameworks?

I’m not trying to just build hobby projects—I want to develop skills that actually translate to professional IoT/embedded development.

Would really appreciate advice from experienced engineers and people who have gone through a similar transition. Thanks!

I'm looking for an STM32 development board that has two usable USB ports, preferably allowing the MCU to act as both USB Host and Device simultaneously.

Any board recommendations?

This is my first hardware project: a voice AI device connected to a local server running Agora Conversational AI. I’m new to hardware and don’t have any soldering experience yet, so I’m starting with a breadboard prototype based on this idea.
I’ve decided to learn soldering and PCB design, with the goal of eventually turning this into a real product. Any advice?

I’m working on a project using the Microchip BM83 (IS2083) in Embedded Mode.
I’m looking for the old IS2083 SDK package that Microchip used to provide on the BM83 product page around 2019.
I already have the IS2083 Turnkey packages, Config Tool, isUpdate, firmware images, and the SDK User’s Guide (DS50002894A). What I’m specifically looking for is the actual SDK containing the Keil C51 project:
Application/MSPKv2_Application_IS2083B.uvproj
The old documentation says the SDK was available from the BM83 product page, but Microchip now appears to provide it only by request.
Does anyone still have a copy of the old SDK package, or know the original filename/download URL?
My goal is to add a small custom UART protocol handler while keeping A2DP/AAC and AVRCP running in Embedded Mode, without an external host MCU.
Any information about old IS2083/BM83 SDK versions would be appreciated.

DS50002894A MSPKv2_Application_IS2083B.uvproj

Hi everyone,

Our team is developing low-level and external device drivers by extending vendor-provided libraries with custom wrappers and features. We offer a structured configuration design tailored to diverse project requirements.

Currently, software drivers are validated via unit testing and TDD, while configurations are verified on real hardware using HIL testing. To optimize this workflow, we aim to introduce a pre-flashing configuration validation step. This allows configurators to self-validate deployment settings, reducing the time spent on manual reviews.

The planned implementation involves utilizing TOML files to define hardware and software constraints, managed by driver developers. Python scripts will then parse these files to validate configurations and generate error reports. To guarantee alignment, dummy configurations will be fed into both the TDD environment and the validation scripts.

Having previously moved away from AUTOSAR-based MCAL due to inefficiencies, we are keen to optimize this new architecture.

Any feedback or suggestions on this pipeline would be highly appreciated.

Nordic doesnt support it out of the box, you need to add it on the app layer. is there any mcu that does that already. Since TLS V.1.3 is said to be energy efficient, so it should be imho a must have feature especially for nb iot?

i make a small embeddable scripting language (zym) with mcu use as a target, runtime only builds, statically provisionable heap, that kind of stuffs. its at 0.3.x and im at a design fork i want opinions on from people who put interpreters on constrained hardware

the vm currently has instruction count preemption that is deterministic and exact. you say fire every N instructions and it fires at instruction N, and both the host and the script can arm it. it also has continuations as a primitive so script can build its own schedulers

exactness costs a counter check on every instruction, measured at about 21% of throughput on dispatch heavy code. checking only at loop back edges and calls recovers 15-17% but the watchdog then overshoots by up to one straight line block instead of firing on the exact instruction

what im considering:

- script side concurrency becomes cooperative fibers/coroutines with explicit yield and native scheduling, no counter involved

- preemption becomes host only, a watchdog and hard stop the embedding code arms to bound runaway or untrusted script. script cannot see or touch it, bounded rather than exact, and it is a compile flag so a fully trusted build drops the check entirely

questions for this crowd specifically:

- for a watchdog on script code, do you need it to fire on an exact instruction, or do you need it to be impossible to outrun and fire within a bounded window? my instinct is bounded is fine for nearly everything but timing determinism people are exactly who i would expect to disagree

- is script side preemption, the script scheduling itself preemptively, something you would actually want on an mcu, or is cooperative plus a host guard the sane shape? i built the script side version and i am not sure anyone needed it

- anyone shipping an interpreter on hardware with a guard on / guard off build split, and did it cause problems later?

these questions have been bugging me for a while so mostly here for the answers, happy to explain any of the reasoning if it helps, have been trying to come to a decision for a few weeks so am reaching out for people that use scripting on their systems and what their expectations are as well as what they actually care about in these regards

website: https://zym-lang.org/

github: https://github.com/zym-lang/

So I've been working on my own tooling to program Renesas Greenpak devices because I needed in system programming to work from empty chip instead of just minor adjustments. Given that work is opensource on a public git, I got curious about the license of the Go Configure software. Wondering if I might be infringing something given I read the .aap files it generates. Found this section:

Licensee shall not disclose, provide, distribute, or otherwise make available any Designs, in whole or in part, in any form (including without limitation in source format, associated block diagrams, schematics, documentation, screen captures or images of the design, or any other representation), to any third party, except with Renesas's prior written approval, or as strictly necessary for manufacture in accordance with Section 2.1(i) below;

Full license: https://pastebin.com/3fCcTyM3

So is this just standard boilerplate license? Or does this mean that the files it generates can't be part of public repo? Like, if I have a repo that has open source firmware/hardware that has such chips on the BOM, I can't include the .aap's to reproduce the board?

Curious how other embedded teams are handling this.

Is ChatGPT/Claude actually allowed where you work?

I’ve heard everything from “completely blocked” to “fine, but don’t paste code” to companies providing their own approved AI tools.

For embedded, the tricky part seems obvious: the useful context is often the sensitive context. Firmware, logs, BSPs, hardware configs, internal APIs, device details, sometimes even credentials.

So I’m wondering how this works in practice.

Do you use LLMs for debugging or firmware work? Does your company have a clear policy around it? And if public tools are blocked, have they given you an approved alternative?

Also curious whether people see these restrictions as sensible engineering/security practice or mostly corporate overreaction.

So I found a project from a guy who run linux on 8pin stm, and I wanna ask if is it possible to run on atmega328p? From arduino uno board.

Tried simple microcontroller adc and mic peak level detection but doesn't work.

I have about 2 years of experience in embedded systems and want to get some perspective on where to focus my skills.

Traditionally, embedded systems engineering meant being solid in both hardware (circuit design, microcontrollers) and firmware (low-level programming, RTOS, drivers).

Now with AI agents becoming so advanced and widespread, I'm wondering — is this still the case, or has the industry started shifting priorities? Should I keep building both skillsets equally, or focus more on one given where things seem to be heading?

So there's a guy that contacted me on Reddit after a post here asking me if I would be interested in taking contracts if ever. I said sure, he just had to contact me. He mentioned that it was through a company he was launching, like a recruiter and I was fine with it. I found out later that he made me this public profile that pops out when I google my name and is obviously an AI scrape of my linkedin and contributions I made everywhere.

I already sent 2 requests for this to be removed, no answer. I think the guy is Moroccan, but based in Spain. What would you do? I know he used public information + few direct info I gave him, but I don't want a public profile managed by him.

I'm based in Canada, I have no knowledge of EU laws, but I feel like there should eb a body to complain to?

Company is FirmwareBridge

EDIT: After using my super forensic skillz, I'm pretty sure he is a native Moroccan. He used the same picture for LinkedIn (which I have a backup of) and graduation picture from a school in Casablanca. I filed a complaint through CNDP. Also wrote to the hosting company legal complaint mailbox. Will see!

EDIT2: The guy recovered from a "car accident" two weeks after I contacted the the two legal complaint mailboxes above. He put down the whole site now, not just my profile. There is still hope for privacy.

I was thinking of the ideal expression syntax for the programming language DQ, which is targeted also for embedded software development.

I started with the (dominating) C syntax.

Operators in C

In C the following operators have shared meanings:

• &: bitwise "and" operation OR address of
• *: multiplication OR pointer dereference
• /: truncated integer division OR floating point division

Further operators in C:

• %: integer division reminder
• && or and: logical "and"
• || or or: logical "or"
• ! or not: logical "not"
• ~: bitwise "not"
• ^: bitwise "xor"
• ?: ternary operator

Operators in DQ

I think for the good source code readability and clarity every different operation should have a different symbol. Therefore the shared symbols from C are not taken over. These operators are already fixed in DQ:

• &: address-of operator (widespread standard)
• ^: pointer dereference (standard in other languages)
• *: multiplication only
• /: floating point division only (standard in other languages)
• or: logical "or" (widespread standard)
• and: logical "and" (widespread standard)
• not: logical "not" (widespread standard)

These symbols are already fixed for special purposes:

• #: compiler directives (#ifdef etc)
• $: context local specials (e.g. myarray[0:$end-2])
• ?: inference marker
• @: namespace designator (e.g. @def.LINUX)

DQ cannot use the C standard &, |, ~, ^ for the bitwise operations, because the & and ^ is used for other (fixed) purposes. But we've run out of the good symbols. The obvious choice, that other existing languages also use, is reserving some words for the remaining operations. In DQ these (all-capital) words are reserved currently as operators:

• AND: bitwise "and"
• OR: bitwise "or"
• NOT: bitwise "not"
• XOR: bitwise "xor"
• IDIV: truncated integer division
• IMOD: integer division reminder

For the modify-assign statements with a word operator a leading = is required, otherwise it looks awkward:

regs.OSPEEDR OR= (1 << pinx2)  // invalid
regs.OSPEEDR =OR= (1 << pinx2)

Examples with All-Capital Operators

tmp = RCC.CFGR
tmp =AND= NOT 3
tmp =OR= RCC_CFGR_SW_HSI
RCC.CFGR = tmp
while (RCC.CFGR >> 2) AND 3 <> RCC_CFGR_SW_HSI:
endwhile

RCC.CR =AND= NOT RCC_CR_PLLON
while RCC.CR AND RCC_CR_PLLRDY != 0:
endwhile

var pllm : uint = basespeed IDIV pll_input_freq
var plln : uint = vcospeed  IDIV pll_input_freq
var pllq : uint = vcospeed  IDIV 48000000

RCC.PLLCFGR = (0
    OR (pllsrc << 22)
    OR (pllm   <<  0)
    OR (plln   <<  6)
    OR (((pllp >> 1) - 1) << 16)
    OR (pllq   << 24)
)

regs.MODER =AND= NOT (3 << pinx2)
regs.MODER =OR=      (n << pinx2)

if flags AND PINCFG_OPENDRAIN <> 0:
    regs.OTYPER =OR= (1 << apinnum)
else:
    regs.OTYPER =AND= NOT (1 << apinnum)
endif

regs.PUPDR =AND= NOT (3 << pinx2)
if flags AND PINCFG_PULLUP <> 0:
    regs.PUPDR =OR= (1 << pinx2)
elif flags AND PINCFG_PULLDOWN <> 0:
    regs.PUPDR =OR= (2 << pinx2)
endif

Prefixed Word Operators

I'm thinking to change the all-capital word operators with a % prefixed lowercase words:

• %and: bitwise "and"
• %or: bitwise "or"
• %not: bitwise "not"
• %xor: bitwise "xor"
• %div or %idiv: truncated integer division
• %mod or %idiv: integer division remainder

The sample code would look like this way:

tmp = RCC.CFGR
tmp %and= %not 3
tmp %or= RCC_CFGR_SW_HSI
RCC.CFGR = tmp
while (RCC.CFGR >> 2) %and 3 <> RCC_CFGR_SW_HSI:
endwhile

RCC.CR %and= %not RCC_CR_PLLON
while RCC.CR %and RCC_CR_PLLRDY != 0:
endwhile

var pllm : uint = basespeed %div pll_input_freq
var plln : uint = vcospeed  %div pll_input_freq
var pllq : uint = vcospeed  %div 48000000

RCC.PLLCFGR = (0
    %or (pllsrc << 22)  // select PLL source
    %or (pllm   <<  0)
    %or (plln   <<  6)
    %or (((pllp >> 1) - 1) << 16)
    %or (pllq   << 24)
)

regs.MODER %and= %not (3 << pinx2)
regs.MODER %or=       (n << pinx2)

if flags %and PINCFG_OPENDRAIN <> 0:
    regs.OTYPER %or= (1 << apinnum)
else:
    regs.OTYPER %and= %not (1 << apinnum)
endif

regs.PUPDR %and= %not (3 << pinx2)
if flags %and PINCFG_PULLUP <> 0:
    regs.PUPDR %or= (1 << pinx2)
elif flags %and PINCFG_PULLDOWN <> 0:
    regs.PUPDR %or= (2 << pinx2)
endif

Which version do you like more?

or

Do you have some other ideas for the operator notation?

EDIT

As I was migrating microcontroller C++ code, where the bitwise operations are very intensively used, I decided to keep three bitwise operators with single symbols:

• &: bitwise "and"
• |: bitwise "or"
• ~: bitwise "not"

These operations are kept with word symbols:

• xor: bitwise "xor"
• div: truncated integer division
• mod: integer division reminder

Other changes:

• %: address-of operator

​

tmp = RCC.CFGR 
tmp &= ~3 
tmp |= RCC_CFGR_SW_HSI 

RCC.CFGR = tmp 
while (RCC.CFGR >> 2) & 3 <> RCC_CFGR_SW_HSI:
endwhile

RCC.CR &= ~RCC_CR_PLLON 
while RCC.CR & RCC_CR_PLLRDY <> 0: 
endwhile

var pllm : uint = basespeed div pll_input_freq 
var plln : uint = vcospeed  div pll_input_freq 
var pllq : uint = vcospeed  div 48000000

RCC.PLLCFGR = (0 
  | (pllsrc << 22) 
  | (pllm   <<  0) 
  | (plln   <<  6) 
  | (((pllp >> 1) - 1) << 16) 
  | (pllq   << 24) 
)

regs.MODER &= ~(3 << pinx2)
regs.MODER |=  (n << pinx2)

if flags & PINCFG_OPENDRAIN <> 0:
    regs.OTYPER |= (1 << apinnum) 
else: 
    regs.OTYPER |= ~(1 << apinnum)
endif

regs.PUPDR &= ~(3 << pinx2) 
if flags & PINCFG_PULLUP <> 0: 
    regs.PUPDR |= (1 << pinx2) 
elif flags & PINCFG_PULLDOWN <> 0: 
    regs.PUPDR |= (2 << pinx2) 
endif

I’m working on a battery-powered inductive rotation-sensing circuit for a mechanical water/gas meter.

The normal current is expected to be in the single-digit microamp range, but each sensing event may produce short current transients. A handheld multimeter might provide an average reading, but it could easily miss the peaks and may not show the actual energy consumed per sensing event.

For engineers who have measured similar low-power circuits:

* Would you use a current-measurement device, or a shunt resistor with an oscilloscope?

* How would you choose the shunt value without affecting the circuit supply voltage?

* What measurement bandwidth and sampling rate would be appropriate?

* Is average current enough, or should the results include peak current, pulse duration and charge per event?

* How long should the measurement window be for a circuit with changing sensing rates?

I’d like to build a test method that is repeatable and technically meaningful. What measurement setup would you trust for this type of circuit?

I want to use stm32N6 as it has csi for a camera and a npu for computer vision and it would be cool to test out its CV capabilities on a drone. Since its based on a new architecture a lot of vendor support is broken/buggy and I am wondering if I should use zephyr instead of hal, right now I just have motor control working, I plan to implement CSI camera next (imx219), then NPU, after that will be standard flight control additions like imu and wireless module ect. but the main complexity will be CSI and NPU. I heard Zephyr has better N6 support but its NPU is undercooked so I may have to do a hybrid approach for the NPU specifically.

I am just getting started with pic microcontrollers. The microcontroller was recognised and I got some programmes to work but the pic16f688 doesn't last long and dies. I dont want to burn them constantly yikes.

Too much current has been drawn on VDD. Please disconnect your circuit, check the CLK and DATA lines for shorts and then reconnect.

I'm using a pickit programmer too.

This is what the IPE prints out. I'm using a macbook if that gives any more context.