Category: Arduino

The Story Of The ST4

You may know about this unique hybrid synthesizer / tracker from us. It just went on sale, it went through a successful Kickstarter, but did you know the real beginnings, and all the nitty gritty? Read on!

ST4 with USB keyboard hooked up.

It all began way back in 2014. I, Pieter, had realized the market for analog monosynth had become flooded. At that time I had worked on a prototype monosynth with a good bunch of knobs (the TCE-1M) and had concluded that it was easily possible, even with all the black magic of analog circuit design and layout. But there were many many competitors. And even the big companies were starting to show interest: Arturia, Korg, Roland, you name it.

Logically, the analog polysynth was next and early 2014 I was working my ass off to get a prototype up and running. Actually, a hybrid synthesizer seemed most practical. Analog VCO’s, like the Piggy’s are a hassle to calibrate and having to do 4+ of those for each unit.. Well, I didn’t feel like it. Plus, like for instance on the Shruthi-1 by Mutable Instruments, digital oscillators added so much power to influence the timbre. It was hard to ignore.

At some point I remember that I had 8 digital oscillators running on the Arduino DUE (a microcontroller board which at that time was the most powerful out there). I generated those using the DUE’s PWM hardware pins and I used even more PWM’s for generating CV’s. It actually didn’t sound bad at all, and CPU usage was low. I also worked a little on the VCF hardware. Steiner-Parker seemed to be the most logical, as it was characteristic as hell, multi-mode, and fairly easy to build. A tip from my mate STU. The VCA’s could be basic OTA stuff. Cheap and efficient.

Conceptually the polysynth was intended nothing more than that. Digital oscillators, perhaps 8, and 8 analog VCF’s and VCA’s. A bunch of knobs to set up your patch and then switch instruments using MIDI CC or using the on-board rotary encoder. A small character display would also be included.

In the middle of things, STU came up to me and was very enthousiastic about all the synth developments I had made, and being a long time fan of his music, it was hard to resist. He wanted to do a special synth, not a generic one like I was making. In retrospect, that was a mixed blessing. A unique instrument with its own idiosyncrasies and niche,  that would make some musicians a lot happier, and we wouldn’t have to compete with the big lads directly.

Read more about the original concept in this huge-ass PDF! original concept and development This more highlights STU’s concept, is a bit older document, but contains more photos than here.

On the other hand, the concept was so eclectic that we wondered what niche this would actually apply to, and also how hard this would be to engineer: A microphone and sampler? 2 analog voices and 2 digital? A built-in tracker (basically a sequencer as used on the old 16 bit home computers).. with a (for a synth) luxurious display?

BTW, a lot of people compare the ST4 with the OP-1 from Teenage Engineering. Could be the similarly playful company names, could be that they are both synths with on-board sequencers. But they are actually very different machines. OP-1 is meant purely as a mini/portable music studio, the ST4 is meant as a high-character synth+chip tracker, even for live purposes: all channels can be directly influenced live: that’s a lot of knobs and buttons, but it pays off!

Far too brave, we decided to push forward. I’d take STU on board as a project partner, if it worked out we might join forces more often. Somewhere in June 2014 we figured we’d have a prototype in September. Nothing was further from the truth.. It was a hellishly complex project with super high integration and fiendishly exotic features. All the eclectic features like the microphone, sample RAM, and the tracker.. And added to this my compulsion to want true polysynth functionality: i.e. one VCF and one VCA per channel.. made the ST4 project a nightmare.

I’ll spare you the details, but we suffered problems on every front. It all started with mixing analog and digital on the control boards. I wanted 10 bit resolution on the pots, but with all the flickering LEDs and clock lines around, that was next to impossible. Even worse was the mic pre-amp. Imagine.. A few millivolts signal surrounded by digital clocks and signals all over the place. After I separated digital and analog supply and ground (which cost several iterations) things were looking up, but even then the pots had to be digitally low-pass filtered.

The original ST4 concept had 2 analog voices and 2 digital ones. I changed that to all digital to spare me the drama. Also, there were a lot of dedicated buttons for the tracker. This was eventually dropped for USB keyboard support. A more sensible choice, if it were not for the fact that we were using an MCU: no operating system, no language support, rudimentary USB support.. So even in this form it wasn’t easy. Also there was the plan to have all envelopes directly accessible. That would have taken a 30 cm wide piece of panel and made the unit extremely expensive, and also might have required the front panel to split: a 70 cm wide aluminium panel will inevitably start bending under all the weight.

Besides all this bad news, we also had a somewhat regular meet-up session. STU had left The Netherlands for his hometown in Switzerland. So, occasionally I visited him or he came over to Utrecht. This worked out quite fine, and we could often develop and test a new feature (like the bitcrusher) in such a session. That often worked much better than plain-old Skype.

Somewhere in fall 2014 I had a “breadboard”, or more like spaghetti model ready. TODO: photo. There were real PCB’s, but the connections were done with jump wires. Error-prone and chaotic. The Steiner-Parker VCF had been replaced by an SVF (State Variable Filter) of own design. A SVF using OTA’s is not a new idea, but I added my own twist to it, at least. No external opamps were necessary. Buffering was done inside the LM13700 IC.. and it worked fine.

Feature-complete model of the ST4 in spaghetti form.

Feature-complete model of the ST4 in spaghetti form.

I remember programming the DUE’s microcontroller, the Atmel SAM3X8E, was an absolute joy in the beginning. Zappy DMA controllers, some even quite easy to set up. Easy and fast interrupts. And the beauty of a 32 bit ARM. I started in Arduino IDE, but because this project was far beyond a mere sketch (eventually 50.000 lines of C++), I decided to use my own makefile system and run from the prompt and sublime text ctrl-b / cmd-b for building and jumping to errors.

Growing out of an IDE was just the first of many “Hulk-like” moments. Painful and brutal, you realize that you have to completely replace a tool or a method. I can say that replacing the IDE was a good one, but replacing the internal PWM with external PWM was a bad one. External PWM chips aren’t as flexible. Fixed resolution, for instance. That resulted in the PWM carrier frequency being 10 kHz. Ok for CV generation, but absolutely terrible for EMC. You’d have the carrier whining through your audio like Satan’s dental drill. So, eventually we went for a bunch of simple audio DACs + a MUX to solve that. There are many more of such examples. And all the while the amount of free pins on the DUE got less and less. The display also ate up a huge amount. Integration just got harder and harder as time moved on. An effect to which many experienced engineers can testify.

In the meantime I took up a great freelance job offer (40 hours a week), and also got an intern. I don’t know how I made things meet, but apparently I did 😉

The intern, Koen, turned out to be a valuable asset. His project turned in to the Sawbench synth. Far simpler than the ST4, but a very nice sounding and easy to use piece of kit. Somewhere in winter 2015 that was done and the production needed to get underway. Luckily producing one synth and designing the other is a pretty good combination.

Work started on the tracker. Well, early on it was just a simple step sequencer with a single pattern. Also the digital oscillators were turned into nice anti-aliased ones. They sound very good up to about 5 kHz. Well, that’s the highest piano note, so above that I really couldn’t care 😉

More and more stuff was visualized on screen, like potentiometer settings, LFO levels, etc. USB support came slowly. The USB library from Arduino was only usable from a non-multitasking viewpoint. So in real life it was useless. I had to turn everything into state machines.. To let that USB code return as quickly as possible. That was a very frustrating but ultimately rewarding task.

The ST4 model of that year was the “woodboard” model with proper ribbon cables between all the PCBs and everything nailed down on a solid piece of wood. See the picture below 😉

Developing for the old woodboard, a new screen to display the full LFO MOD matrix.

Developing for the old woodboard at STU’s place, a new screen to display the full LFO MOD matrix.

Also with the software it turned out that integration was hell. Consider the 96 kB of SRAM… consider semi non-existent libs for USB keyboard handling, and minimalistic display libraries.. That means yes, all human interfacing stuff including GUIs, keyboard handling, language, etc, needs to be done by the same coder. I was used to this, many years of game and demo coding had hardened me, but the ST4 still was special. The thing is so feature-rich, yet so underpowered in hardware and software libraries, that almost every new feature will turn into a hassle to code.

2015 really was a damn hard year in that respect. The easy part was getting the prototype casing from Protocase. It’s never exactly what you would like, but at least it’s sturdy (and heavy!) as fuck 🙂

ST4 in its prototype steel casing

ST4 in its prototype steel casing

In terms of electronics, the mic board was finished. No real noise there. Perfectly fine for 8 bit sampling. The power supply part was also done. We figured an external AC/AC supply and internal AC/DC with classic regulators and diode bridge could work, and it did. The real work was spent on integration and prototyping, though. Countless times redesigning the wiring and pinning, resoldering, re-routing, re-ordering from PCB factories.. The ST4 was already functionally complete late 2014 (hardware wise), 2015 was only refining and software!

So, late 2015 that prototype was finally done.. It worked very nicely. You could show everyone what the thing could do without wires breaking or so 😉 The tracker and the live tweaking of the filters were especially fun to see people do. Even old musician friends from the Atari scene 🙂

In the meantime I decided to split with STU because I didn’t feel the cooperation worked well enough. As it turns out, making a synth is 90% execution and 10% concept. And the bigger the synth, more the more it skews those numbers! A full-time concept maker (and general techy/musician) is perhaps not best in such a super-critical project.

Still, we decided to do the Kickstarter campaign together. We joined up and shot a video together with a professional cameraman / editor. Then I put the Kickstarter campaign up early 2016. Since we’d already won a Kickstarter for the Sawbench, we’d thought it’d be easier this time. Well, yes and no. People were much more enthousiastic about the ST4. We became big in Japan overnight, even 😉 tens of thousands of views on all kinds of social media. People loved it. Yet the number of pledges was not in proportion. In the end, we just made it. The last night I couldn’t sleep and just sat at the keyboard trying to hype the thing up.

This was one of the biggest things I learned. What people love and what they buy are two different things. Sure, there’s always an overlap, but with the ST4 that turned out to be pretty small. We were puzzled by this. Not everyone can afford a Ferrari, but this is a (simple) Ferrari at rock-bottom price! A 4 channel hybrid with 40 knobs and countless of buttons and LEDs, a gazillion interfaces, a relatively large full color display (for a synth), pretty damn powerful unique functions.. for a mere 800? And most of it is not cheap plastic and consumer parts like in many modern budget synthesizers. It’s all durable metal, automotive rotary encoders, metal sliders! My hypotheses to explain this effect is that either the interested people are poor, the rich guys can’t believe it’s that good, or people don’t trust larger sums of their money with a new brand. Most likely all of the above.

Still, we made it. I asked Jasper and Koen, by then my partners in crime, to help out a bit and they did. I asked a skilled graphic designer (Nuey San Waldman) to design the front plate graphics, logo’s and everything, and he did. I refined the firmware and the last bits of hardware revision were done early summer 2016.

After that the hardware assembly and making of all the DIY kit bags started. We were already finished in August! In the background there was the casing design. The Sawbench had been much easier. The ST4 was multi-mount: 19″ rack and desktop, and there was just so much stuff inside. To shrink down from the over-dimensioned prototype casing down to the sleek one we have now, loads of boards needed to be resized. So we had to assemble some boards all over again.

Mod board kit (bag D) separate kit bags, part 1.

All those kit bags. There are bags A through J, and there are bags in bags.. in bags. This is D: the mod board.

 

Behold, the box. Behold the official ST4 logo!

Behold, the box. Behold the official ST4 logo!

 

But most of it was just finding the right factories for metal, powder coating and silkscreen paint. Iterating and negotiating. That, all in all, took nearly half a year. But in February 2017, a whole year after the Kickstarter, it finally all came together. The final product is very good, if we may say so ourselves. Sure the firmware still has some hick-ups when using some of the more advanced features, but these are being ironed out as you read this. The thing is beautiful to look at and handle. The pots and knobs are the highest quality you can expect. There’s visual feedback on everything and there’s tons of way to use it. Not in the least tracking it live, or using a PC keyboard to play and hack in notes, and then wiggle some VCF controls. What machine can do that? 🙂 We’re extremely proud that we pulled through and did it the hard way. Because love is for the hardest people.

IMG_9742

The insanely good looks of the ST4 along with heavy Depth-Of-Field 😉

ST4 September update, DIY kits

Just to keep you informed, another ST4 progress update. In the last weeks we’ve tested the sample casing and we’ve requested another one. Two PCB’s didn’t fit correctly, the other 7 did just fine. This will take until early October.

In the meantime all the presets have been added, the DIY manual has been updated with better tables, and we’re ironing out all the firmware bugs. ..And.. we’re finally compiling all the DIY kits. Still, that’s not too much work. The casing is the only real work that’s left. We strive for November, but the planning is now in the hands of the casing factory.. At least you’ll be getting your gear when you spend most of your time indoors. It makes sense 😉

The current collection of kit bags (half of it, actually).

The current collection of kit bags (half of it, actually).

In the meantime we did a minor Sawbench hardware revision (to protect against wrong AC/DC converters) and we’re looking forward to test the 1.2 firmware with its improved VCA/VCF envelopes and improved MIDI support.

Kit bag, with spiffy new label. ;)

Kit bag, with spiffy new label. 😉

When the final casings arrive we’ll start shipping out the kits ASAP! This is done in first-come-first-served order:

1. Kickstarter DIY backers first to last
2. Kickstarter assembled version backers first to last
3. Pre-order list DIY first to last
4. Pre-order list assembled version backers first to last

Today we’ll send out a questionnaire to ask you guys which version you want: rackmount or desktop.. and to ask you for your postal address.

Casing, boxes, and plugged holes

Dear ST4 backers,

This is not the post you’ve been waiting for.. not yet. But we’re close. Very very close.

Today the sample casing was completed.. and it’s on its way here. The casing is without silkscreen paint, but all the metal and powder coating is there. It comes furnished with metal impact standoffs to easily and reliably fit all the electronics. And as you can see the rear electronics can be fitted in two ways, for either:
– rack mount
– desktop

Powdercoated ST4 sample casing.

Powdercoated ST4 sample casing.

Just like we promised. In desktop form the holes on the bottom plate can be plugged. Cover caps are supplied for this. Note that we will ask whether you want the rack or desktop version when the time arrives. And yes, you can still easily switch from rack to desktop or vice versa.

Furthermore, the cardboard boxes were also delivered to our office!

Behold, the box. Behold the official ST4 logo!

Behold, the box. Behold, the official ST4 logo!

Firmware 1.0 is as good as finished. As planned, we succeeded in making LFO and modulation settings per instrument. We’ve included the option to sort 100+ long sample file names. We’ve hit a point where new features just eat a bit too much CPU and/or memory and that means we _have_ to finish up. We’re just doing testing right now, and adding presets!

No telling when the big moment will be there. November seems pessimistic, while mid september seems optimistic. It all depends on if the electronics fit in right away, or we need to move some bits around. The silkscreen paint jobs _seem_ trivial right now, but with the Sawbench, for instance, the color was a big issue for the previous factory. Digital printing turned into silkscreen and in the end that delayed things by 4 weeks.. But we choose quality!

We’re sorry for the delay. We especially underestimated the casings. This is not a small or simple device like the Sawbench, so logically there are more questions, more things to discuss, and more price and feature negotiations. We just didn’t know how much more, exactly. Thank you for your understanding.

ST4 Production

In recent weeks the ST4 electronics production has kicked off. Many of the simpler boards have now been produced and are ready to be built into the ST4 units. These were handmade right here at Tasty Chips labs in The Netherlands, just like the Sawbench synth was.

A stash of assembled ST4 VV boards.

A stash of assembled ST4 VV boards.

The more complex boards (exp, vcf, vca) are being assembled by machine in a fab nearby and should be done by the end of the month. Concerning the manual labor, we still have to do the voice and the mod boards. The DIY manual has also seen some major progress and many of the board pages are supplied with photos of all the soldering steps: ST4 DIY resource. More and more detailed information will appear on this DIY resource in the coming weeks.

In parallel, the firmware is still being worked on. Some news:
– Poly mode now works fine and is intelligent enough to allow 3 finger chords + solo.
– The ST4 tracker can now send MIDI out clock signals.
– The ST4 tracker accepts MIDI clock input (preliminary).
– Samples can now be tuned.
– Sample looping can be turned on or off individually per instrument.

The casing (graphic) design is ongoing. We’ve got an excellent graphics artist on board to help us with the silkscreens. The details of the fabrication are being negotiated at the moment.

Last but not least. We’ve had multiple requests whether the ST4 will become available to the public after Kickstarter. The answer is YES! Also, we are taking pre-orders. These are completely free of charge and the interested party is not obliged to buy in any way. Just send your name, postal address, and the version you want (kit, or built unit) to tastychipselectronics@gmail.com. Price for built unit will be 850 eur, 550 for the kit. Units are shipped out on a first-come-first-served basis.

The last of the piggies.

With the year coming to its conclusion, it seems an amusing coincidence that the last Piggy now finally got sold. 🙂 The Piggy was our first synth, a simple and affordable shield that turns your Arduino into an MIDI-driven analog bass synth.

The Arduino Piggyback Synthesizer

The Arduino Piggyback Synthesizer and its host system, the Arduino Uno.

We might do another batch.. The filter would need to be revised (dual gang potentiometers are getting rare!), maybe even changed into the Sawbench VCF.. But we need to know if there is enough demand. The usual address applies tastychipselectronics@gmail.com. Either this or post on Tasty Chips on Facebook or Tasty Chips Forum.

Looking at what’s in store for 2016:

– The ST4. This beast of a synth/tracker has got its own page here: ST4 info page. As said, the Kickstarter will take place in january!

ST4 in its prototype steel casing

ST4 in its prototype steel casing

– The Sawbench mod board: modify the Sawbench to accept external CV for VCF and use and external input signal (If there is enough interest).

– Sawbench firmware update 1.2: including synced LFO, tighter envelopes and possibly exponential envelopes too (If there is enough interest).

– A big analog Eurorack sequencer with 2×16 steps and loaded with features.

– Sawbench VCF/VCA Eurorack module.

– The next polyphonic beast. This will be less channel-driven than the ST4, but will have more channels (yes, that does make sense 😉 ). The focus will be on polyphonic harmonic sculpting..

– The MIDI sequencer (“tracker”) taken from the ST4 released stand-alone, with more controls geared towards pure sequencing.

Autumn update: Superpiggie follow-up and “ST4”

Time for a little update after many months of silence on the blog.

Tasty Chips Electronics are still going strong. All the original Piggies have been sold and so we’re going to do a follow-up 😉

The Superpiggy prototype will be a blueprint for this device, although it’s likely it will feature a real VCF instead of a manual filter, along with some other features. The goal is to keep as high a fun-factor as possible, yet also usable as a serious analog monosynth. The product name is not known yet, but there is some idea about the release date: early next year. Also, we will opensource the original Piggy hardware (software was already open), as a sort-of thankyou to the whole Arduino community. 🙂

Meanwhile, the big polyphonic synth project is still ongoing and the prototype is now being integrated with everything on it:
– 3.2″ display
– about 50 knobs
– 4x multi-mode VCF’s
– 4x stereo VCA and mixer
– countless leds and buttons
– MIDI, SRAM, headphone and all other stuff

The ST4 breadboard. Well, part of it..

The ST4 breadboard. Well, part of it..

The SAM3X8E, the micro controller in the Arduino Due, is not powerful enough to control all the analog hardware on its own. A whopping 16 Control Voltages (CV’s) are necessary to control all analog units such as VCF and VCA. So additional PWM IC’s along with output filters were added to the design: these can be controlled by SPI, so the amount of Due pins used there is not high.

Also the display took a huge number of GPIO pins: 21 in total. And all the other devices such as button, potentiometer and led control required many other GPIO pins and analog inputs. All-in-all, the Arduino Due hasn’t got any more pins.. And that’s how we like it: really using the hardware to the fullest, yet keeping it completely transparent for the musician.

Overall, the SAM3X8E and analog electronics now feel like home, just as much as the Atari ST and Falcon once did. This synth, codenamed the “ST4”, will be an ode to those machines of yore. Straightforwardness, directness, fun factor and reliability are the first things we considered. We merge these things we appreciated so much from the early days of computing and computer music with the characteristic beauty of analog audio circuitry; The multi-mode VCF is our own unique design and is very smooth and warm. You’ll love it! 😀

Arduino DUE Makefiles

The Arduino IDE is good for starters as it hides some of the complexity of C++ development: notably the linker and project management. It is intended for beginners so they can have a LED blinking in 2 seconds. And you can extend it using libraries based on C++ classes, which is great.

Correction, this SEEMS great and it would be if it were implemented right. Of course, the editor is somewhat limited compared to matured platforms such as Sublime text, or the typical IDE editor.. However, that’s not the real problem here. It’s good that it’s simpler than those powerhouses, otherwise beginners would run away. The real problem lies with the project management.

Normally, you’d have a project setup which defines dependencies between classes. Mostly, the user sets this up manually or semi-automatically (for instance using CMake or GNU Autotools). The major advantage of this is that no unnecessary code is ever compiled or
linked.. and when changing only 1 file, only that file is recompiled and linked.

What Arduino IDE does wrong for the DUE (and I’m talking about the recent version 1.5.6):

  • It recompiles everything. Even the core libraries.
  • It cannot reliably tell which libraries to include or not.
  • Verification of upload is always done, even when you explicitly set a flag not to. This takes ages.

Especially the second point is deadly. It causes error messages about missing #include statements, while these shouldn’t have to be there at all. Not only this but an unnecessary library can be linked, causing the maximum code size to be exceeded!

The other points are primarily annoyances of ours. But compilation and upload speed IS important. Uploading big programs to the due can take 30 seconds or so. And verification doubles that. But verification is only required when you’re performing diagnostics. Forced recompilation of core libraries adds another 10 seconds. Better make some tea.

But back to the deadly second point. Assume we have the following piece of sketch code:


#if 0
#include "Foo.h"
#include "Bar.h"
#endif

void setup()
{
….

Foo and Bar are our libraries and we disabled their inclusion by using preprocessor directive #if 0. Much to our bemusement, this didn’t do anything. The libraries were still linked and the upload was still as big as before. The first thing to do in Twilight Zone episodes like this is to wipe your glasses. Correct your monitor angle and try again.. But no.. Nothing was wrong with our code.

What then, was the problem? What happened under water in the depths of the IDE was that our sketch got scanned for library includes. But the scanning was implemented in such an improper way you’d actually be surprised that it works at all. It’s just a “grep”.. A line by line search for the #include directive. It doesn’t take into account the context at all. Instead it should do parse the C++ code, but it doesn’t. We don’t know why. But we also shouldn’t care. After witnessing this it was clear that the IDE just wasn’t designed with bigger programs in mind.

Finding a bug in a big program can be a very time consuming task, and this could make things a lot worse, especially when maximum program size is exceeded for no reason. Added to this is that fact that the IDE also seems to think #include’s are missing, like mentioned before, was really the limit. Let’s just do it properly, shall we?

Our solution is just a typical makefile. Makefiles are ancient, their syntax a bit cryptic, but they always get the job done and they never change. Learn once, and use the rest of your life.

The start was to check the IDE’s compiler output:
Arduino -> Preferences -> Show verbose output during compilation

This produces a huge mountain of GCC and GPP command lines. We’ll spare you the actual raw text here and analyze it for you. What is there to do when building a DUE sketch:

  • Build the Arduino core library. This features implementations of the well known digitalWrite(), analogWrite(), and everything else an Arduino sketch uses. Eventually we intend to completely replace this with our own code (as it’s a million times more efficient). But for now it has to stay. The process is hard to generalize. Every piece of source can be in a different subdirectory so we ended up with 100 lines of Makefile code.
    Sources get compiled to object files (.o) and these get archives into core.a.
  • Then there’s the non-core libraries. For instance, SPI.cpp. Compilation proceeds similar to parts of the core.a lib but are not archived. Your own libs should be compiled in a similar fashion. Note: For some reason syscalls_sam3.c should also be present as a separate object and not (only) be present in the core.a.
  • The ELF should now be built from the sketch source and all the objects and the core.a should be linked.
  • The ELF should be dumped to a .bin using objcopy. This is used with “-O binary” mode, meaning it strips all symbols and relocation info.
  • Finally the .bin should be uploaded using bossac. This is what we came up with:

    # erase the DUE!.. done by opening comms @ 1200 bps
    stty -f /dev/cu.usbmodemfd121 raw speed 1200
    # actually upload the binary
    bossac -p cu.usbmodemfd121 -e -w -b test_ili9340.bin
  • Serial output can be monitored with a combination of screen and cu:

    sudo cu -l /dev/cu.usbmodemfd121 -s 115200

    ..And just kill the screen Using ctrl-a k when we’re done.

As you can see it’s not that crazy. Of course, loads of definitions of include paths, GNU tool locations and compiler and linker flags are necessary. For your convenience I’ve put them in a ready-to-go Makefile attached to this post (it’s a display driver test):

test_ili9340

Enjoy!

Scroll to top

Now shipping pre-orders. Dismiss