Search results for:

I don't know why Nordic's solution was that nasty hack with PPI

I think they wanted to avoid reconfiguring SPI interface from the new EasyDMA SPIM to the older SPI one (as it is actually somehow different HW block inside). That saves them to touch/reset lot of registers including speed, mode, interrupt flags etc. Maybe for some engineer it was not nasty but neat and clever trick to use PPI so it could stay working in DMA mode. But still your fix may be actually more practical.

It doesn't matter much for 1 byte transfers but in theory the test could be if (count==1 && rx) because it is rx dma what triggers the bug, sending one byte without receiving anything (i.e RXD.MAXCNT==0) works fine. not sure what is actually faster or make more sense - using dma for sending just 1 byte or disabling it, sending and enabling back.

would that explain the issue you see or it is something else? happens only if you are both reading and writing exactly one byte over spi with dma, looks like tx cannot stop after first byte properly if it is waiting for receiving byte. if you don't read and just write one byte it works ok.

not sure if it is related or there already is fix in espruino code for this issue but there is known bug when sending and receiving one byte over nrf52 spi with DMA, see https://devzone.nordicsemi.com/f/nordic-­q-a/16401/sending-single-bytes-over-hw-s­pi-0xff-appended-every-other-time with link to workaround zip with source or see directly https://infocenter.nordicsemi.com/topic/­errata_nRF52832_Rev2/ERR/nRF52832/Rev2/l­atest/anomaly_832_58.html?cp=4_2_1_0_1_8­ for issue described

Took some forgotten unused DS-D9 fitness band with very small hard to read display, updated to latest Espruino and with this font at size 19 the clock is now very readable and fits perfectly https://streamable.com/lmdtd8 Thank you.

because with any IDE I could manage my modules and the only thing to upload is one file... so there it lost importance.

So would that idea I mentioned help - require("module") would first try to load module from opened tab with same name? It is still sort of hack as those tabs are now unrelated, some extra project file would be better so whole set would be treated as one project and then module could be loaded even if it is not opened in tab, and whole set could be closed or opened. But even without this project management, would it be worth it to have this simple way? I hope it would be relatively easy to add to this.

EDIT: oh what gordon mentioned - uploading each module to storage before main file is also solution for this

Thank you. Not sure if github.io hosting is somewhat special but the webide itself is hosted at https://www.espruino.com/ide/ in same/similar way without needing node.js or chrome extension too.

opened https://floriandh.github.io/EspruinoWebI­DE/ in Chrome
see screenshot https://ibb.co/7V5zK3m the error marked happens on each click and dialog does not close. Also there are other errors on load, maybe related.

Very nice. Tried it, went to https://floriandh.github.io/EspruinoWebI­DE/ but cannot create javascript file, it throws "code.js:137 Uncaught TypeError: Cannot read property 'setFilesArray' of undefined at HTMLButtonElement. "

also one letter name "t" gives error "Name cannot contain whitespace".

Can it load other files from other tabs as modules? i.e. you have tab "module1" and "main" and main would use require("module1") and it would get loaded from the other tab?

Fixed - loads great now: https://www.espruino.com/ide/emulator.ht­ml?gist=27711cd5003478d18f3c0dbea9e6cb61­&upload

Wow, this is really nice. I was not really using vector font (even compiled it out from build to save space) becasue the output quality was not that great but this is very good. Thank you @NebbishHacker

Since it is vector based, can it be scaled in both dimensions? like g.setFont("Vector",14,16) so the height is 14 and width of largest letter 16 - i.e. to make it more fat? Or thin/condensed when I really want to fit more letters but still have the full height available?

Hello, nice, just checked it briefly and I am not sure about the 64bit time in processSample, what is the precision? miliseconds? can it be 32bit? or can I perhaps set frequency once? or send zero if this is just next sample with no delay. I guess I get batch of values from kx023 per interrupt but don't know the time, but values are probably spaced evenly with some preset frequency. But I guess I can start with time zero and then just increment 64bit value by some constant with each sample.

EDIT: also looking into the code and ther is 64bit math used, is this really needed?, wouldn't 32bit integer or possibly 32bit float type be enough for such task?

x,y,z data from kx023 is only 16bit

well esp32 is not very power efficient when compared to nrf52, see e.g.
https://github.com/Xinyuan-LilyGO/TTGO_T­Watch_Library/blob/master/docs/power.md
https://github.com/espressif/esp-idf/iss­ues/947
so yes, great for ESP32 fan or if you don't care about battery life that much

Just a followup. I also got the 16bit mode working and it is visibly slower. 30ms more is really visible difference. Also rewrote the framebuffer/palette lookup reading code so that I can have 3-bit 8 color mode (pixels not aligned to byte boundary). Unfortunately Espruino does not support that, learned after it was already done. After adding bpp=3 to isValidBPP here https://github.com/espruino/Espruino/blo­b/master/libs/graphics/jswrap_graphics.c­#L181 it almost works, just have some wrong thin blank vertical stripes where the byte boundary is crossed. will check how easily it can be fixed.

Also as for colors I tried some dynamic palette for bpp=1 mode so I could change colors between flips - to have multiple colors with only 1 bit framebuffer. And it can work like that for many things without a need for full 2 or 4 bpp. With 1bpp the first cube rotating screen and then second shape fill screen look almost same as before. Only random lines show some nice ZX Spectrum style color artifacts :-)

Current code is still here also briefly described how one could self host the compiler https://github.com/fanoush/ds-d6/wiki/Es­pruino-Inline-C if you want to modify it.

It is actually pretty nice environment with inline c, one could upload code quickly without even touching the flash memory and try anything freely. With watchdog enabled bugs are harmless. Thinking about exporting unused interrupt vectors from Espruino as this is currently clear limitation of inline C - I cannot hook into SPI interrupt in the driver now. Something like E.set/getInterruptVector(intNo) would do. Any vector unused by current espruino build could be exported like that.

ILI9341 driver - see.

Oh, nice, thank you for linking that, the canvas idea with different smaller areas of different bit depth is interesting and could save memory. I think that is what @Gordon was adding to Espruino in recent days? Then you don't need to have whole framebuffer (28K in my case for 16 color 4bit one) and could blit such areas directly. E.g. for fonts there is otherwise no other way than to draw each pixel separately which is very slow as seen in the simple driver example here - that one was very painful to see on P8.

Not sure what it will do with memory fragmentation to create such (relatively large) memory blocks dynamically. With one framebuffer you create it once on the beginning. And with around 300 variables free I am experiencing issues to get small flat strings created, this gets triggered sometimes unless I put the code to flash.

The rotating cube looks quite fast

Oh, that one is even fully drawn in javascript running via setInterval() so that the device is still responsive.

Also this was first meant as quick prototype to try various methods of sending data quickly, I am a bit surprised it can be probably used as standalone driver as is. But of course proper way is to merge it with driver code https://github.com/espruino/Espruino/blo­b/master/libs/graphics/lcd_st7789_8bit.c­ and possibly just change macros/methods here to put same data into some buffer and trigger DMA when buffer is filled istead of using 8bit mode.

I don't know as I did not see both next to each other, but previously I thought 8Mbps SPI with 240x240 must be pathetic (see this forum post and the video there) but this is not so bad.

There is no DMA for 8-bit parallel mode so the code must do both at once - palette conversion and/or scaling and sending to display. Wth DMA you can compute first block of pixels in advance and then both can run in parallel. With larger blocks than just few bytes the DMA could amost reach maximum theoretical 8Mbps speed. So e.g filling 240x240 in 12 bits (1.5bytes per pixel) takes 96ms when using dma in 24byte blocks.

Even if there is mode when the DMA does not stop and can send several buffers (or same buffer) repeatedly on its own automatically, for some reason letting it loop over 6 byte buffers or 24byte buffers in such mode is a difference. With just the 6 byte buffer in code above it it was still like 125ms ~= same as sending it without DMA, and the 3byte buffer was even slower.

The P8 smartwatch is good one to hack and put Espruino onto it. It can be updated without taking apart and is quite cheap ans has full touchscreen and 240x240 ST7789 display.

Here is demo of Espruino build with display driver implemented as Inline C code.

https://www.youtube.com/watch?v=PgB1PQA5­_OQ

While there is already support for this display for banglejs, that driver is not SPI based. There is another one for previous F5 watch here but that one has framebuffer as static variables. I tried to update it to banglejs driver style but the whole "1. build espruino, 2. flash to watch, 3. see it crashing , 4. repeat" cycle was too slow so I first tried to prototype it in javascript and inline C and see ho far I could go with this.

This uses DMA in similar way as the spilcd driver but was written from scratch without using nordic SDK to learn about ST7789 and nrf52 EasyDMA and SPI hardware (first version just bitbanged SPI RXD and TXD registers without using DMA).

BTW it is interesting how much JS interpreter is slower, try to use g.jsflip and see the difference, the code is otherwise the same. While Espruino performance is otherwise OK here it really struggles.

SDK14 and SDK11 based builds are here with some instructions.

Oh and BTW thanks for cube animation, it was stolen from pixl.js conference badge code

I could also not cut&paste my error message from the IDE left panel. Would be a nice enhancement too.

It should work and is copied to clipboard automatically when you select block and release mouse button (unless it is very large). However it would be also nice if all output from left side could be automatically saved to some log file. Would help a lot with larger blocks that are too large for clipboard. Like e.g. dumping 4MB SPI flash memory via loop of btoa() calls :-)

Assuming not just straight forward as updating start address in Linker script?

If uploading over SWD then basically yes, look how banglejs is done.

With only using DFU package it is more complicated to install such moved bootloader. You first need custom build of espruino with one more line added to as per comment here then you need to erase UICR area in NRF.onRestart method, write bootloader via espruino Flash module and then write new bootloader location to UICR. I have done it few days ago, several times, have scripts for this. Not hard and not even that much dangerous unless the bootloader binary you flash is not working.

This was all only about moving bootloader, downgrading SDK is more complex if you need bootloader as there is no bootloader for SDK11 in espruino source so you need to get another one, e.g. from nordic examples. Without bootloader, with SWD flashing it is quite easy as the source builds as is with this extracted and you get 12+32KB

to actually move all storage onto the flash memory

Was thinking about actually move only some storage to external memory. How easy is to have code in Storage in internal flash and then have second instance of Storage object/module for data in external SPI memory? Or maybe have one Storage but multiple drives or paths like ".boot0" in internal as before and "ext:data.bin" or "ext/data.bin" in external? But two instances like e.g. SPI objects could be easier - just a flag which one it is. I guess modules cannot have parameters like require.("Storage","internal") or require("Storage")("internal") like described here?

Idea is that code is relatively small and can run in-place in internal flash but data can be large. Also running code in internal flash may draw less power when javascript source is not continuously interpreted by reading over SPI.

if show() is slower than 100ms it probably gets queued up, try to increase the interval

Without external flash you can also save a bit by downgrading to SDK11 - gives you 0x1f000-0x1c000=12KB and also the bootloader can be moved by 8KB 0x78000 to 0x7a000 - giving you 20KB in total, not much and quite tricky to do. Also you can do build without bootloader if you use SWD debugger to upload the firmware. This gives you 32KB more compared to current state.

They are aournd $20USD on BangGood

if buying from china these are more like $5, e.g. here https://www.aliexpress.com/item/32847322­743.html
What is inside is actually nice generic USB2.0 chip FX2LP CY7C68013A which is quite versatile (firmware is loaded over usb, there are opensource examples) and there is even slightly cheaper 'developer' board that can work as this logic analyzer - it is the same thing or even better as it has 16 channels, not 8. It is between $3-$4 like here https://www.aliexpress.com/item/32976439­459.html

Definitely good thing to have.

Oh and it is documented here https://sigrok.org/wiki/Lcsoft_Mini_Boar­d and the 24MHz 8Ch analyzer is e.g. here https://sigrok.org/wiki/MCU123_USBee_AX_­Pro_clone

That's not my case as rebooting the watch doesn't fix the issue

depending on what apps you have installed you can be low on memory right after rebooting so can still be your case

That's not right for me, and I suppose for many other iOS users. WebBLE doesn't seem to be a reliable solution for managing my Bangle.js. Also, I expect to have watch notifications from iOS in a near future

Just checked kickstarter page and it clearly says:

• We’ll be adding support for notifications from GadgetBridge on Android, but don’t have any plans to support iOS.
  
• Web Bluetooth works on Windows 10, Mac OS, Chromebook, Android and Linux. iOS requires a cheap paid app (WebBLE).
  
  

That is the only occurence of 'iOS' on that page. So hopefully it is not big surprise for you (and for many other iOS users).

Maybe you can help with developing such iOS app?

Since there is already Arduino library available, will it be worth to try to add the C code in Espruino src as a lib and compile it locally?

If it is worth to you then go on. However arduino (C++) code and Espruino C code can be quite different so it may not be trivial to port arduino library to espruino. C module is necessity if you cannot do it in JS (no JS api exposed) or for performance reasons. However you lose the modularity. Anyone using same sensor would need to build own espruino version. If you do it as JS module the code can be put here https://www.espruino.com/modules/ and people can use it without custom Espruino build.