#video by #Bitluni of #bitbang #NTSC and PAL video signals from ESP32 #microcontrollers using I²S. Waveform animations showing the h-sync pulse, etc. Recommends watching CNLohr’s videos for color.
#Bitluni #video on how ESP32 #microcontrollers can #bitbang #NTSC and PAL color, including YUV equations, etc.
#NTSC and PAL waveforms, etc.
the terrorist Casio F-91W watch used by #Daesh and by Ramzi Yousef in 01994
#ACME automatic certificate management extension for TLS certificates
#ACME support for nginx
#ACME support for nginx
#video from 02023 by Michael Hill (#bitfixer) of his "esp32s3vga" library, not really bitbanging VGA signals on ESP32-S3 #microcontrollers for a “new retro computer”, simulating an 8-bit CPU with 8 megs of SPI RAM. Actually it includes an RGB LCD driver peripheral that’s perfect for this, which can even use external PSRAM; he’s using a 25MHz dot clock with 640×480 because 25.175MHz wasn't stable, and 40MHz for 800×600. There’s a demo of playing 3-bit-per-pixel and 8-bit-per-pixel (R 3, G 3, B 2) video from an SD card in SPI mode. #retrocomputing
my prediction last month of global borderless Slaughterbots drone war following Operation Spiderweb
ooh, tiny IPS TFT #displays #pricing down to US$6.37 for a 240×320
#video of Endoh’s #IOCCC winner, a raytracer written in the #C preprocessor.
an excerpt from a Boke of Kokery from around 01440, with a recipe for Garbage
Full scanned page from the 01440 Boke of Kokery with the Garbage recipe.
a really comprehensive artice about 1-bit #DACs and #sigma-delta modulation. #DSP #communications
Menabrea’s sketch of #Babbage’s Analytical Engine, translated by Lovelace. #history
Tromp’s binary #lambda-calculus #esolang
Setting up STM32F407VG #microcontrollers to DMA data from a memory buffer to a GPIO port
#PDF #appnote on #STM32 #microcontrollers: many of the line (but not STM32F) support DMA multiplexing
you can get #STM32 #microcontrollers such as an STM32f103rb running at 64MHz to DMA data from memory to a GPIO at 2MHz using a timer
#video by "simonmartin_ch" of how you can get #STM32 #microcontrollers such as an STM32f103rb running at 64MHz to DMA data from memory to a GPIO at 2MHz using a timer. Using STM32Cube tho. He sets bit 8 (UDE he says) in TIM2->DIER to make TIM2 generate DMA requests repeatedly. Also he’s using the TIM2 output compare signal itself as one of his output signals and using circular DMA mode. He says at 4MHz you get a lot of jitter, even with “High” priority (visible from 3’25"). A commenter “synergie8” warns that on STM32F2 and STM32F4 DMA1 can’t be used with GPIO, so you have to use DMA2 and consequently TIM1 or TIM8.
you can set up DMA on #STM32 #microcontrollers such as the STM32F407VG to write data to a GPIO port controlled by a timer; to enable DMA on timer 1 rollover, you select channel 6 on stream 5 on DMA 2 with DMA2_Stream5->CR = (6u << DMA_SxCR_CHSEL_Pos) | stuff and tell the timer to generate a DMA signal on timer overflow with TIM1->DIER = TIM_DIER_UDE.
1757-page #PDF of #STM32 RM0090 reference manual for STM32F4xxx, section relevant to routing DMA requests to DMA controllers: Table 44 shows that Channel 6 of Stream 5 on DMA 2 is TIM1_UP. There’s a 3-bit field CHSEL in DMA_SxCR which selects which of the 8 channels is active for that stream. §§17.3.2, 17.3.6, and 17.3.9 explains that you need to set various bits in TIMx_DIER to enable generation of DMA requests from the timer; §17.4.4 on p. 570/1757 has 15 bits to enable interrupts and DMA requests on different conditions, such as UDE, “Update DMA request enable”. But the STM32F1xxx is different.
#PDF of #STM32 RM0008 reference manual for STM32F1xxx, §13.3.7, relevant to DMA request routing. On here all the possible request signals for a channel just go into an OR gate, and there’s a single EN bit for the whole channel. TIM1_UP is one of six signals on DMA1 Channel 5. “The 7 requests (...) are simply logically ORed before entering the DMA1, this means that only one request must be enabled at a time.
The peripheral DMA requests can be independently activated/de-activated by programming the DMA control bit in the registers of the corresponding peripheral.” No CHSEL field. §14.4.4 TIMx_DIER looks exactly the same as on the STM32F4xxx, with UDE, CC1DE, TDE, etc. §14.2 clarifies: “Update: counter overflow/underflow, counter initialization (by software or internal/external trigger)”.
another #video of #STM32 DMA, this time to onboard DACs on a 168MHz STM32F405RGTx. But the sampling rate is only 100ksps. #toread maybe.
how the ZX81 generated video; they added a timer in the ULA to generate HSync pulses and poke the CPU with NMIs when it needs to generate data. #history #retrocomputing
#UK #news: #facial-recognition vans with #neural-networks to search for, supposedly, sex criminals. #human-rights #privacy
"Ofelimos", a provably-secure #cryptocurrency based on proof-of-useful-work combinatorial optimization #paper #toread
provably-secure #cryptocurrency with proof-of-useful-work with #neural-networks!? #paper #toread
is #Qubic launching a 51% attack on privacy-focused #cryptocurrency #Monero?
discussion claiming #Qubic is not actually launching a 51% attack on the #Monero #cryptocurrency
#video of roller/pinion #mechanisms patented in 02019 in Korea and China but denied in Taiwan.
#video of four hours of #Blow on #IMGUI. He’s programming in #Jai and struggling to understand why his UI isn’t doing the right thing. I think this video might be from 02021, halfway through his Sokoban game. In watching frame by frame, I notice that he has one (or sometimes two) frames of lag before initiating mouseover effects (tweened animated fades to brighter colors, etc.) on his IMGUI widgets. (Some of them “breathe” at about 1Hz when the cursor is over them.) Also a frame or two of lag is visible with the mouse pointer when he’s dragging windows. He sure spends a lot of time restarting his game; it takes 8 seconds from recompile initiation to seeing the cutscene, and then by default it plays for a few seconds, though it can be cut short to a single second. if ui.begin(panel, resizable=false) { ... defer { ui.place_rect(0, outer_margin); ui_end(); } ... ui.radio_button(*debug_mode, .Lightmap, *theme); ... ui.separator(); ui.label("Paint color", w=100); ui.same_line(); ui.color_edit(*paint_color, linear=false); ... if ui.button("Swap colors") { Swap(*paint_color, *clear_color); } ... ui.separator(); ui.checkbox("Airbursh", *airbrush); It seems like his .separator() is a small amount of vertical space. For tooltips, ui.hint("Radius of the brush - Wheel"); ui.input_float(*radius, w=64); ui.same_line(); ui.label("Radius");. There are ui.indent(); ... ui.unindent(); pairs for some visual hierarchy, but the indents are very subtle indeed. There’s a ui.enable(bool) for graying buttons out until a ui.enable(true);. The video shows how useful it can be to have video recordings of GUI interaction for debugging; at 43'33” a bug misinterprets a mouse movement dragging a window as also moving a slider, which mystifies Blow, and at 43'57” he erroneously speculates, “Must’ve accidentally dragged that, real fast?” At 45'16” he’s looking at another bug where a “clear” button isn’t being clipped properly and is overdrawing an accordion-control button in its parent. He gets into the implementation arount 54'44”. His definition of “em” is wrong by a factor of 2. He sure spends a lot of time manually doing small table layouts that a sort of elastic tabstops would solve for him. The implementation figures out when to pop up “hints” (tooltips) with rect := place_rect(w, h); over := is_over(rect); update_hint(over); and detects clicks with over && (ui.mouse_button_left_state & .START), and I think place_rect handles moving you to the next line and widening the current line. It’s interesting to hear him using Tk terminology like “entry” for “text field” in 02021. The RGBA color picker is interesting; I thought maybe you dragged up or down from R, G, B, and A buttons to adjust the respective color components, which changes the colors of the buttons to the corresponding primary shade, but in fact they’re just “checkbuttons” that change color when you click them. I like text_height, text_width := text_size(text);. Fading out a border around the window to α = 0 gives a nice cheap fuzzy-drop-shadow-like effect. I feel like for indentation some kind of current-drawing-origin stack might be a good complement to the clipping stack (“scissor stack”, maybe nomenclature borrowed from glScissor). He spends a lot of time debugging problems induced by how Jai’s static type system doesn’t have an Option type for optional parameter defaults. His defensiveness is grating: “The last thing I need is for someone who’s been programming for 5 years to tell me what I do and don’t know.” He’s hashing the addresses of callsites (plus an optional integer for loops) to get unique widget IDs for the IMGUI library. Casey #Muratori pops on at 2'56”, explaining that nowadays he streams his IMGUI drawing commands into a command buffer, sort of like ocornut’s dear-imgui, but higher level so he can run layout algorithms over it afterwards. “The reason I like the command buffer approach is because I like to be able to have more logic in the layout stuff.” Muratori’s definition: “IMGUI just means that you don’t call Create and Destroy on widgets. It means that there’s no need for you, the user, to like record what they are. (...) The core problem that you're trying to solve, and the one that determines whether I call it an IMGUI or not, is, can you just run some code on your side to output the current state of the UI, and you never have to think about whether some previous thing you said will make the UI, like, appear different, right? So you can just say, one pass, here’s what the UI should look like, and that is what the UI will look like.” Blow asks at 3h14m8s: “Was it Sean who used to do the IMGUIs where you would like call the function twice, once with display off and once on?” Muratori: “Yep.” Blow: “Did you ever do it that way?” Muratori: “I think I have played with doing it that way but I don't remember ever liking that.” At 3h19m55s Muratori explains how he did the React virtual-DOM diff and merge thing on his “command buffer” to draw an IMGUI with Qt, pointing out that you could do the same thing with HTML. Oh, at 3h45m50s there’s how scrollable sections work (though it has some bugs where scrollbars don’t show): ui_begin_scrollable_section(*results_scroll_value, w=..., h=...), with presumably a corresponding end call later. He has just a ui.selection_list inside it in that case, which turns out to be a loop calling ui.button for each item in the array which returns the index of the selected button. And I’m amused to see that ui.button is just a call to ui.checkbutton which passes a null pointer for the state, which ultimately calls draw_button with 8 positional parameters, which calls draw_label, which calls text_origin to figure out where to draw the text. Very educational video, even though I think some of the code is kind of naff, like ui_end(false, true). I managed to finish the whole video.