AB07-USB3FMC: The $1.65k eval board they can't be bothered to test
lab.ktemkin.com
lab.ktemkin.com
A very annoying experience.
I bought the product to fulfill a need. If it can't do that, then you don't get to keep the money. Nobody hands money over for some vague, nebulous promise of something in return.
[1] K.S.A 50-624, http://kslegislature.org/li/b2019_20/statute/050_000_0000_ch...
[2] The actual limitation to disclaimers is at K.S.A. 50-639, http://kslegislature.org/li/b2019_20/statute/050_000_0000_ch...
[3] E.g. K.S.A 84-2-314, http://kslegislature.org/li/b2019_20/statute/084_000_0000_ch...
Does the Kansas law apply to software as well? That would be a neat trick. There was a national effort to get this level of support in the UCC (universal commercial code) but as I recall it was unsuccessful.
Heck, where I worked, most eval boards ware usually side projects given to summer interns or new grads or outsourced to India.
A hilarious example - to deal with the poor reliability of the RPi, you might think to use its watchdog timer to reset the device if it locks up. But guess what? The WDT in the crappy Broadcom chip on the RPi doesn't work! It's supposed to be there, and it's exposed to the kernel, but it doesn't actually do anything.
Seriously, why the hacker community even touches the RPi is beyond me. It is a ridiculously closed product.
In fact I'd bet most of them would be scared off by the several thousand pages of documentation an SoC like that usually would have.
1) glue shit together
or
2) read several thousand pages of documentation
who is going to choose the latter?
This is a market that's being poorly served (maybe it's not big enough to justify investment in developing non-shitty products for them?) but blaming the users seems distasteful.
Is that any different from all that stack overflow copypasta you find all over source code, where the paster clearly had no idea how that code worked? And I’m talking about people who are being paid to ship code.
shudder. It’s a wonder anything functions at all these days.
Not to pick on anyone, but I recently installed a stock storybook setup. Out of curiosity I did a count of all the node_modules (top level + nested). There were >2000 packages installed.
Now I know that if I follow the rules of a textbook professional (one that takes security seriously), then I'm obliged to audit all 2000 packages. But between you and the rest of the gazing internet, I don't do this. That's my dirty little secret. I don't give a shit. Gluing orphaned half-assed npm packages together and pretending everything is okay is my job.
The ironic part is how many hours we are murdering worrying about TypeScript or unit tests or integration tests and trying very very very hard not to notice that landfill we have placed under our massive rug.
There are too many technologies and not enough time to master them. Every time I dive into a popular node package I become more and more worried for the human race. We get things fundamentally wrong and it lives like that. For decades. And people come along and just obliviously use it like that and don't question it. Take something simple, like JWT. Or nonces. Or what people believe and implement around random numbers and how random numbers work (or, often, don't work). Bad information becomes bad code that sits around for a lifetime.
I started on ARMv5 back in the days of Sheevaplug/Dreamplug. At least that had JTAG, even if the cable did cost $70.
I have tried:
* Espressobin: While Marvell's hardware is pretty good, they've had trouble with the v7 board, resulting in the small community being somewhat bifurcated. I still don't think it runs a mainline kernel properly. At least the PCIe slot is standards-compliant. u-boot+ATF will always be a 2018 (?) Marvell fork, no one's ever going to update that.
* Firefly RK3399. Lol. https://lkml.org/lkml/2020/4/6/320. Although, if you can get ARM Trusted Firmware working it's a reasonably competent board.
* Vocore2. Support is reasonably helpful but insists that I use GCC 3.4.2 to compile the bootloader. Remember to back up the wifi calibration data - you can't ever get it back if you erase it. You will need to break out the magnet wire if you want to unbrick it. Shame, it's a nice little MIPS board.
* Anything Libreboard - use this, they've put a stunning amount of work in to get things upstreamed.
When I want to just work on something not on a PC, I keep coming back to the Pi. The Pi 4 is competent with an SSD attached over USB 3, and the Pi 0W is great for very simple tasks that need Linux. I wish it were better, I wish Broadcom was more open, but the Pi has the biggest community I've seen in any "hobbyist" ARM space.
Seriously, it's easy to crap on this stuff when you're willing to recommend boards that cost "just 20 dollars more", or have one-hundrenth the community because most of the end users are embedded engineers or the anything-but-a-pi sub crowd.
To me it just shows a lack of ability to consider requirements in evaluation. Even something as simple as the fact the rPI form factor has been fairly consistent for a while is a huge boon to people just trying to start with this stuff.
I could give my mom a rPI and a $20 starter kit and she could probably get to the point of a working PC.
I wouldn't dream of that with anything else. The fact it's Broadcom based is a little unfortunate but that ship has sailed and the ecosystem around it now trounces any benefit of alternatives for the actual people using them. Not embedded engineers who say it's crap because they wouldn't make a custom product based on that SoC.
-
This is like when people point out that for half the price of an Arduino Uno you can get an STM32 board that will run circles around a dinky ATmega328.
It's not about the power or "objective goodness", even the header layout of the Uno lets beginners use an insane wealth of peripherals designed for it
There is an Arduino port to STM32 (Blue Pill in particular), for those whose idea of embedded programming involves a bunch of delay() statements scattered around the library code, making sure no other peripherals can be used while you’re polling for the next UART char..
There's a million and one peripherals designed for that specific combination that don't work seamlessly with other boards (even within the "official" Arduino family)
I mean your complaint about the quality of the library code, it's perfectly fine that the code sucks if it lets people do 1 million and one things they couldn't otherwise.
Do you really think someone programming an Arduino for controlling their cosplay LEDs cares if the library they used is poorly written? As long as it works it works.
They were never going to read the datasheet for an MCU and start figuring out bit masks for pin initialization, so it's literally a case of something is better than nothing, and there's no reason to gatekeep the environment that lets them use embedded systems
(A few employers ago, they were the only source for ethernet PHYs for a carrier-grade network product we were building where we supplied our own MAC)
Commercial embedded stuff is better but not without warts. A former colleague of mine sent me a rant a couple of weeks about one which I won’t name, but the board vendor couldn’t even get a Linux kernel to boot reliably on it when it was shipping to customers.
Engineers and power users tend to forget that the Raspberry Pi wasn't designed for them.
The target market for the Raspberry Pi doesn't care about reading the SoC datasheet or connecting the latest NVMe drive that costs several times more than the SBC. They just want a cheap, simple board that lets them start learning and tinkering with ample resources available on the internet. The $35 Raspberry Pi excels in this regard.
Please do! It would be very good to know that your vendor is doing that.
For example the Honeycomb LX2K at https://www.solid-run.com/nxp-lx2160a-family/honeycomb-works... or the NVIDIA Jetsons at https://developer.nvidia.com/embedded-computing.
Those options have the advantage of using SoMs so that you can customise the boards for a higher-volume run too.
The regular RPi on that point isn't exactly ideal, but depending on the use might be quite _okay_.
It was around 3 years ago. I haven't touched any ARM board ever since. We specifically used OrangePi zero. The armbian at the time had thermal management problems to the point the boards would straight up fry to a brick. I remember there was an update that fixed the thermal problem but it would corrupt the SD card once in about five reboots. And it really didn't solve the thermal problems. They'd get hot enough to be unresponsive. So the clever decision by management was to add a fully self designed avr based board to periodically poll the device on one of the GPIO pins and somehow reboot the OrangePi if it didn't respond. So reboots were common and SD cards only lasted 1 month tops.
If anyone knows of an alternative that's in the $100 (US) price range, runs linux, and will make my life easier, I'm grateful for suggestions.
Oh, and it needs to play nicely with a USB-to-ZWave dongle and one of the major open-source home-automation packages that can do lighting controls.
EDIT: I forgot to mention that I want it to reside in a closet that has very little ventilation. So I'd be leery of deploying a cheap used x86 system, even if the price way right.
EDIT2: Holy crap I'm being high-maintenance here. I should just do a damn Google search like everyone else.
The power system doesn't suck like the RPi series. The chips are all well-documented with the possible exception of graphics. It has eMMC so you don't have the microSD idiocies if you don't want them.
And if you need genuine real time, it has two RISC cores (4 on the AI) that operate in actual real time as opposed to Linux kinda/sorta/when-it-works/maybe real time.
"But the RPi is cheeeeeeaaaper!" <grumble>
Bullshit. The beaglebone can be permanently damaged (not just filesystem corruption!) BY BEING UNPLUGGED: https://elinux.org/Beagleboard:BeagleBoneBlack#Improper_Powe...
Never had crap like that happen to a raspberry pi.
Uh, yeah. A failure mode so rare that they can't isolate it.
RPi--the system that overdraws every USB interface on the planet and requires special power supplies. RPi--the system that couldn't even get USB-C right. RPi--the system that shuts down when you fire off a flashbulb (not their fault--but still a power failure). RPi--the compact system that needs a heatsink or it shuts down.
RPi has lots of things going for it. The power system is NOT one of them.
(If you want to pick on Beaglebone power systems, pick on the PocketBeagle. It has some truly stupid failure modes.)
My main frustration with them is that there's a ton of outdated documentation around how some of the software stack works. It's changed quite a bit over the last 5 years and you can easily go down pointless rabbit holes.
The Beaglebone series really does lots of I/Os well.
Worry about a better product for your next build.
Also, like the sibling said, just do it. If every option is ARM, there shouldn't really be much of a difference if you swap the underlying system.
Couple years ago I bought a pile of barebones ex-Datto Alto, NUC-style, AMD GX-415GA systems on eBay for sub-$5/ea and I reach for one of those for pretty much anything that doesn't Actually Need an RPi. RAM runs $5-$10 for 4GB, $20 for a 2.5" SATA SSD. They boot much faster than a Pi, idle around 7w, and run fine in my "network closet" that gets over 100F in summer.
Those exact systems aren't plentiful on eBay any more but there are tons of NUC-alikes, actual NUCs, and Thin Clients in the $40-$75 range with low-TDP CPUs of comparable performance.
Pi 4 as home server value proposition gets bad fast for me at least once cases, power supplies, storage etc factored in.
I've got more than a thousand of the previous unit in production. just ramping up on APU units. yes they are higher power than a Pi, but still very low. easy to develop for (amd64). tons of Ethernet ports. easy to use reliable storage. USB3, SATA, mpcie ports, SIM slots. openly available schematics
Not a lot not to like!
You could consider the more expensive Jetson Nano if you need a powerful GPU or if you just want to try something different. People tend to assume it's faster, but the Raspberry Pi 4 CPU actually beats it in most cases ( https://syonyk.blogspot.com/2019/11/battle-of-boards-jetson-... )
Client bought too many to change.
I know of a museum with a huge Pi deployment and they don't have issues like that at all.
It's not like they overheat and lock up in 4 hours, it's more like randomly in a day or two. But since they're just monitoring stuff every couple min, it probably felt safer to reboot all the time.
Not sure exactly about the decision process that went there, I just did part of the software running on them. But they definitely weren't stable long term.
So your pihole doesn't heat as much as the pi in that kiosk even given the same room temperature. And then, the temps inside an outdoor box in the sun can go way up too.
1) Eval board design typically begins before the ASIC design is finished. This means eval boards are frequently subject to last-minute design changes (because something in the ASIC changed) and/or intense schedule pressure for the design to be completed and the boards manufactured between the ASIC design freeze and when the ASIC comes back from the fab. Last minute design changes and high schedule pressure are not conducive to high-quality engineering.
2) Eval boards frequently have multiple purposes. The primary focus of an "eval" board is likely to be test platform for the ASIC, and customer evaluation is a secondary goal at best. As an external customer of the eval board, you're not even the _primary_ customer - the primary customer is the internal testing team. If "easy for the test team to use" and "easy for an outside customer to use" ever come into conflict, the test team is going to win.
2b) Because eval board's real target customer is a team within the company that has access to the ASIC documentation, preparing external documentation is a low priority. And since eval boards can indirectly expose embarrasing bugs in the ASIC, design secrets, etc., the external documentation is either heavily redacted, gated by onerous NDAs, or both.
3) Eval boards aren't the product - the product is the ASIC - and selling eval boards is rarely profitable on net, so there's pressure to keep the costs down. In the same vein, the PCB team for a semiconductor company is considered lower status within the ASIC company (if they're even part of the company and not contractors or an outside design house, which is also very common). This doesn't mean they're less skilled, necessarily, but it does mean they have fewer resources and less influence within the company, so "eval board" issues are going to be low priority.
3b) Because eval boards are a net loss, the incentive to go back and clean up any issues caused (1) and (2) is low to non-existent.
4) Because the eval boards _never_ go to high volume production, the eval board design team frequently has no experience or motivation to do proper DFM (design for manufacturing) or DFT (design for test) on their PCBs. Assembly is frequently manual because the volumes are too low to justify setting up (and debugging) an automated assembly line, leading to high product variability.
5) The eval board price is intentionally high to filter out non-serious users who're not engineering with a plan for eventual high volume production. Sales reps may just eat the cost of some dev resources if it enables a volume sale, or get it reimbursed as promotional expenses.
I met with a field engineer for a major chipmaker. I asked him about the samples that he tossed to our group, he said he usually just got them from DigiKey.
+1. Also, they know you cannot do your job without them, and anyone who's buying one is a company with a budget, thus, it allows them to set the price to the maximum that is still accepted by companies. It's not unusual to sell a $200 eval board for a $2 commodity chip. Fortunately, at least for cheap commodity chips, the reference schematics and layout is often available for free.
Each board was tested multiple times, there were inspectors after almost every step, to the point that each board was inspected at least 4 times during assembly, and then 2 separate full tests were done on every board. No sampling, each and every board was tested. Speaking to the engineers, our projected defect rate was <1%, and we achieved that. However, for rough numbers, this 1.6K board would likely cost >10K to achieve that level of reliability.
So the board was booting up fine, you just couldn’t talk to it. We excited the chip wasn’t going to survive and indeed, it didn’t.
Since they'd shipped these boards for a while it was pretty likely nobody was using them. Since nobody wants to design around a part likely to be cancelled due to poor performance in the market...we figured nobody would be relying on this part.
I called it a "pullup capacitor" because it was where you'd expect to see a pullup resistor and thus the name is funny.
In any case, having covered circuit boards is a critical part of the reliability equation in consumer electronics. In an EE environment, component-level access and visibility can make it worthwhile to deal with naked boards, but you inevitably drop a few nines of reliability.
What is a lot more likely is one of the following:
* Engineer sent incorrect assembly drawing (sometimes when components are shuffled around with silkscreen/assy drawing layer hidden, the label for component can end up in unexpected place).
* Someone manually updated the part numbers from one revision to another and missed the one resistor.
* A new engineer joined a project, and after minor unrelated change to project, regenerated the fabrication outputs as one should. But he was not aware of changes somebody else did in BOM file by hand.
* PCB assembly was performed by hand for prototype and contained an incorrectly placed part, but the assembled PCB ended up being shipped because of complete lack of production planning, somebody in sales selling stuff before it's ready and this being the only option to avoid contract cancellation.
I have personally witnessed every one of these and then some.
Yes, product engineering sometimes really is that shoddy and people being people stupid things.
No, resistors are not always fully encapsulated, especially if they are small, cheap, and/or designated for high speed applications, and no, the ones that are encapsulated are not protected well enough to make high or intermittent resistance failure modes particularly unlikely after being poked. I've seen both cracking and scraping in the wild. Not as many as I've seen shorted MLCCs, but that would be a tall order.
Sure, it could also have been a design failure, but every time I've found one bad resistor in a bank of identical resistors, it has always been a physical problem with that resistor. Shrug.
Another source of cracking could be related to moisture in the SMD components. We do primarily small volume PCB runs where I work. In house, with parts stored here, pick-and-placed here, etc. We have had components crack as well, and I recall one of the suspicions being the source of the components. They were a supposedly reliable supplier, but components from them failed more often than those from another supplier so we stopped getting parts from them.
I am not sure if resistors are as prone to humidity effects, but if plastic parts are not humidity controlled before going into a reflow oven, they are prone to cracking. Even as a software guy, I have seen several brand new boards with cracked components on them over the last 15 years. Often the cracked components are difficult to find, since they are so small and do not fail completely (they are just off by a wide margin.)
https://www.google.com/search?q=smd+resistor+tape&client=fir...
I've seen so many assembly errors in my time that I'm pretty sure it was something like this that happened.
It is in many places. See my comment elsewhere in this thread. You may be unfamiliar with it in gender-neutral use, but it does exist.
There are places where "you guys" is unusual. For example, when I moved to a certain part of Texas, it was unfamiliar to the people living there. Perhaps you live in a place where "guys" is uncommon and are unfamiliar with the term. In that case, I suggest you respect other people's cultures and embrace diversity.
Guys, this doesn't have to be so hard. Just check the authorship before commenting about the author! If you get it wrong and someone points it out, say "oops, I should have checked" and it's over.
Please don’t assume our gender when preaching to us about inclusive language.
This, right here, is precisely why this issue is important. We have gendered pronouns that are so ingrained we try to pretend they're not gendered.
"All" is a _shorter_ and more inclusive substitute for "guys".
If you think this isn't important, just replace every occurance of "guys" that you see with "gals". If you're cool with that, good on you, but if you think for one second "oh don't say gals that might piss someone off" then, well, there's the kicker.
Then you have limited E.
If you followed the link, you should've seen that I wrote "OP is an engineer and I guess she has been trained to always do it", so I thought it would be all you need to understand "why", isn't it?
But if not, to elaborate - The likely explanation here is: Engineers are trained to do it in their jobs, and for someone from an engineering background, it's possible to "make this choice" automatically without even realizing it, and for them, it's totally a natural number without any readability issue. In the same sense, if you see a software developer who expresses a number in the power of 2 even when it's unnecessary, it may not be the most appropriate decision, but this type of behavior is totally understandable. You don't have to be a rocket scientist to see why.
For the ARM firmware, there is a short document called "Using the FX3 SDK on Linux Platforms"- it was pretty straightforward. It's arm gcc, plus a qt-based program called "cyusb_linux" to interact with the FX3's bootloader (you program it over USB).
https://www.cypress.com/documentation/software-and-drivers/e...
You can use Eclipse if you want (they have some kind of support for it), but I just used the Makefile in the example projects.
The ARM firmware uses ThreadX RTOS, but the actual application is pretty small (and the space is very limited as I recall).
The only stupid thing is that they have this thing called GPIF-II designer, which I think is a Windows-only tool. The final output is a table in a C header file. I think it's a .NET program, so I think it would be easy for them to support it in Linux, but they don't.
[0] These rules are not always enforced, and there are alternative notations, but the 1-1000 rule is the most common convention, writing "3500 MHz" instead of "3.5 GHz" is just awkward.
I wonder where else that's used on the board, and if this is a pick and place machine error.