https://github.com/PJHkorea/consciousness-auto-rotation-artificial-neural-bypass/blob/main/fluxmesh_hybrid_test_core.h

This project focuses on implementing a real-time signal detection and noise acceleration core engine tailored for 64-bit native embedded environments. By completely eliminating heavy multidimensional matrix operations and partial differential equations (PDEs), we achieved high efficiency.

Standard hardware architectures are heavily limited during high-frequency, real-time processing because of electrical noise and sensor dropouts. Our engine solves this at the software level using a low-cost, grid-array-based chip topology. Instead of relying on expensive single-board computers, we use a grid of low-cost microcontrollers that only talk to their immediate neighbors (North, South, East, and West). Imagine a dense, chessboard-like hardware layout made of ultra-small, cheap MCU chips. This setup guarantees deterministic execution timing and provides incredible fault tolerance.

1. Achieving 0% Cache Misses via Flat Scalar RegistersTo hit a strict 1 kHz deterministic loop timing, we completely ditched multi-dimensional arrays (float[][]) and pointer chasing. Instead, all algorithms are fully flattened down to the scalar register level (p00, p11). This allows the native 64-bit FPU to directly map the registers and execute them in a single clock cycle

2. Branchless State Rotation (Zero-Jitter 'if' Processing)We completely eliminated conditional statements (if statements) from the core execution path to prevent CPU pipeline flushes. Noise mitigation is smoothly handled through a Layer 1 vertical state rotation mechanism, which effectively notch-filters high-energy noise using continuous rotation.

3. Real-Time Scaling using Padé [1/1] Rational ApproximantCalling heavy transcendental functions like exp() inside a high-frequency loop is a major timing risk for embedded CPUs. Our engine swaps this out for a Padé rational approximant, turning the exponential curve into a simple arithmetic equation. This drastically cuts down the computing cost needed for continuous mapping.

4. Derivative-Free Mesh Bypass (Autonomous Fault Isolation)If a specific node suffers from non-stop, extreme noise or physical dropouts, Layer 1 automatically triggers local apoptosis and broadcasts an isolation signal to its neighbors. Instead of recalculating heavy PDEs across the whole grid, the engine applies a cross-axis negative sign (-) coupling to adjacent outputs. This clever math trick sparks a spontaneous clockwise vorticity (Curl), smoothly routing the signal flow diagonally around the dead zone until the faulty node bounces back to a stable state.

The app includes the ability to assess up to 17 more sites with a 4 channel. Community based norms and assessment of those sites is available in addition to the ClinicalQ.

There is also an app that has removed ClinicalQ data and relies on community based assessment.

As long as you can create EDF data files you can use this.

If anyone on the forum is using BioEra software I can provide you with a design that leads you through recording the ClinicalQ data gathering. I have a limited number of slots for this. If you do this you will receive a copy of the assessment for up to 17 sites at no charge

Thanks

I'm a software engineer beginning work on an open-source project and I'd like to pressure-test the idea with people who actually work in this space before I commit to building it.

The project: a standalone desktop application that performs real-time EEG source localization (sLORETA/eLORETA) using a template head model and renders estimated cortical source activity as a color-mapped overlay on an interactive 3D brain mesh. The intended tech stack is Rust, wgpu for GPU-accelerated signal processing and rendering, and Tauri for the application shell. Data acquisition via BrainFlow, with BIDS dataset support for offline replay and analysis. No MATLAB dependency, no cloud, runs locally on commodity hardware.

The gap I'm trying to fill: source localization algorithms are well-validated and the computational feasibility of running them in real time on a GPU has been demonstrated in published work. But as far as I can tell, no usable open-source standalone application exists that does this end-to-end — ingesting live EEG, solving the inverse problem, and rendering source estimates on a 3D cortical surface at interactive frame rates. The existing tools either do source localization offline (MNE-Python, Brainstorm), operate only in sensor space in real time (NeuroSkill, OpenBCI GUI), or require MATLAB.

My background is in systems programming, not neuroscience. I'm investing significant time in domain knowledge (working through Cohen's Analyzing Neural Time Series Data and the Nunez & Srinivasan text, and studying MNE-Python's inverse solution pipeline as a reference implementation). I plan to validate against the Localize-MI ground-truth dataset before making any claims about accuracy.

What I'd like from this community:

• Does this project address a real need in your work, or is it solving a problem that doesn't meaningfully exist in practice?

• For those who do source localization: is a template-based approach (ICBM152, no individual MRI) useful enough for your purposes, or is it too imprecise to be worth visualizing in real time?

• What channel counts and devices would this need to support to be useful to you? Is there value in supporting consumer devices (Muse, OpenBCI Cyton) for source imaging, or is that misleading given their limited spatial sampling?

• Are there existing tools or projects I've missed that already do what I'm describing?

• What features would make you actually use this versus your current workflow?

I'm not trying to replace MNE-Python or Brainstorm for offline research analysis. The goal is specifically the real-time visualization layer that currently doesn't exist as a standalone application. If this turns out to be a solution in search of a problem, I'd rather hear that now than six months from now.

Appreciate any candid feedback — critiques included.

I’ve been trying to access the headset's data stream by way of LSL, but I am a bit confused about the number of samples I have been getting when saving the file. I am trying to capture data for the periods of time when a user is watching a video, for example a two minute video I assumed would have approximately 15,000 samples per channel at a sampling rate of 125Hz. Even though I made sure to turn the toggle from file to network the samples have been closer to 9,000. I double checked the sampling rate and it seems to be at 125Hz as well as collecting data from the two minute interval.

I think it may be from the code I have written: https://github.com/necode2/attempting_collection_eeg/blob/main/2_collectingEEG.ipynb
I've been trying to reference documentation and found a few helpful videos from UCSD who talk about building a simple data collection framework.

All I have been attempting to do up until this point is:

• connect to stream
• create markers
• access my stimuli
• have a loop that goes through stimuli file and
• launches stimuli
• sends a start marker
• records for duration of stimuli
• sends ending marker
• share shape of file
• saves file to a designated location
• and then asks the user if they would like to proceed with the next stimuli.

To answer any quick questions regarding packet loss:

• My dongle is plugged into a USB-C to USB adapter
• I have less than a 10 ft line of sight between the dongle and the board (generally closer to 1-3 feet)
• I do fully re-charge the battery after a few hours of use.

I would truly appreciate any pointers or help anyone can provide, and apologies for all the trouble. Thank you.

• Train a fatigue-prediction model on the CogBeacon dataset
• Use precomputed absolute and relative band powers (δ, θ, α, β, γ) × 4 channels
• Align each “round” of band-power features with self-report button-press labels
• Engineer features such as θ/α and θ/β ratios, moving-window trends, and session scores
• Train and validate classifiers (e.g., logistic regression, random forest, CNN-LSTM) with cross-subject evaluation
• Deploy real-time fatigue alerts for new users
• Stream live EEG from an OpenBCI Ultracortex during any deep-work task (studying, coding, etc.)
• Compute the same features in fixed windows (e.g., 10 s epochs with 5 s overlap)
• Predict emerging fatigue early (before the user consciously feels it) and trigger break notifications
  I’m planning to prototype a cognitive fatigue detection system using the OpenBCI Ultracortex. I’d love to hear from anyone who has worked on similar projects or has suggestions regarding electrode setup, feature extraction, signal preprocessing, and real-time deployment. Also, any recommendations for tools, libraries, or datasets would be greatly appreciated!* *

I saw on some of the forum pages that MindAffectBCI was suggested for this use:

https://openbci.com/forum/index.php?p=/discussion/3619/low-cost-way-to-get-started-pong-game

so I tried to follow:

https://openbci.com/community/mind-controlled-robot-openbci-mindaffectbci-maqueen-v2/

which uses MindAffectBCI. I tried setting up the python package using the tutorial and with the other github link

https://github.com/wjcroft/pymindaffectBCI

But for some reason when I run the test command

python -m mindaffectBCI.online_bci --acquisition fakedata

the java server is connected and the python window opens for a second but gives the following error:

in update_nch
self.background = pyglet.graphics.OrderedGroup(0)
                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AttributeError: module 'pyglet.graphics' has no attribute 'OrderedGroup'

I'm not exactly sure what I should do next, and I tried different versions, but none of them worked any better. Could someone point me in the right direction? Is using MindAffectBCI a lost cause since it appears their project has been abandoned? (the github is deleted and a lot of their youtube videos have been removed). Are there any alternatives?

Loading pipeline...
INFO: execution started
INFO: execution resuming
INFO: Importing XDF file C:/Recordings/CurrentStudy/exp1/slater1.xdf...
INFO: Imported file C:/Recordings/CurrentStudy/exp1/slater1.xdf.
INFO: Imported file C:/Recordings/CurrentStudy/exp1/slater1.xdf.
INFO: Resolving data stream (name='obci_eeg1')...
INFO: Applying FIR filter...
INFO: CSP model is training now...
****ERROR: The following error occurred in node Common Spatial Patterns: shape of data ((2, 4)) must match lengths of axes ((2, 6))****
WARNING: The channel labels of the given stream were missing or incomplete. Auto-generating labels.
INFO: LSL: Data stream obci_eeg1 acquired.
ERROR: CSP must be trained before it can be used

Honestly I'm not sure where to begin looking for the "Common Spatial Patterns" node to figure out why the data shape doesn't match the axes length. If I just run the pipeline without editing it (with no EEG input from my headset) it executes appropriately. Where should I start looking? Any suggestions will be appreciated. Thanks!

The tutorial mentions that motorimg_calibrate.py is found in the extras folder in your Neuropype installation folder. Specifically the tutorial mentions "Start the Lab recorder and find the OpenBCI EEG stream in the window. Now run the python script motorimg_calibrate.py found in the extras folder in your Neuropype installation folder".

I can not locate "motorimg_calibrate.py" anywhere. I wonder if someone can help me locate it or provide a suggestion on what to do?

I see some people using Mindaffect BCI to do something similar but I think it only supports 4 channels and wet electrodes, though I'm not completely sure. I'm new to programming so any guidance would be appreciated.

I wanted to create a game to help kids with ADHD focus better.

I’m excited to share a project I’ve been working on that could open doors in BCI communication.
https://logicprogs.ca/eeg_translator/
I’ve developed a simple EEG Translator – a web-based tool that takes raw EEG data (CSV format) and translates it into English words. It works by comparing pasted EEG values against a predefined CSV mapping file, where each EEG pattern is linked to a corresponding English word.

How It Works:
You paste your raw EEG data (from OpenBCI recordings) into a text box.
If a match is found, the tool displays the corresponding English word(s).

⚙️ Built With:
JavaScript, HTML, PHP for frontend and backend
CSV pattern matching (no SQL or database needed)
Built for compatibility with OpenBCI’s .csv EEG recordings

Use Cases & Vision:
Assistive communication for users with speech/mobility limitations
Brain-to-text experimentation
Educational demos for how BCI can bridge neural signals to real-world actions

Why I’m Posting:
I’d love to get feedback, suggestions, or collaboration offers from anyone here who's into:
Pattern matching and brain signal analysis
Improving EEG accuracy/translation speed
Looking for openBCI raw EEG data recordings as csv files because the current translator translates only neurosky raw EEG data
Please share your eeg you recorded with openBCI so i can create the version of translator for openBCI

Real-time integrations with OpenBCI live streams
If you're curious to try the prototype, I can share the tool, or show how you can map your own EEG patterns for testing.
Let me know what you think — I’m here to learn, improve, and maybe impress a few minds along the way

Thanks,
Ervin Zenelaj
Founder @ LogicProgs BCI / Cyborgs
logicprogs.ca

https://openbci.com/community/mind-controlled-robot-openbci-mindaffectbci-maqueen-v2/

This tutorial shows how to control Maqueen V2 robot with your mind using OpenBCI board and MindAffectBCI open source application.

What you need:

• OpenBCI board (Ganglion Board or Cyton Board)
• EEG Headband or cap
• EEG electrodes + cables
• MindAffectBCI
• Maqueen V2 Robot
• Micro:bit

Here is his Youtube demo:

If someone were to write Python code to connect to an OpenBCI Cyton Biosensing Board (which has 8 channels), several interesting outcomes and functionalities could emerge, benefiting researchers, developers, and hobbyists in the fields of neuroscience, biomedical engineering, and wearable technology. Here’s a breakdown of what might happen:

1. Real-Time Data Acquisition
   Functionality: The code would allow users to acquire real-time EEG data from the Cyton board. This includes signals from the eight channels, enabling users to observe brain activity as it happens.
   Outcome: Researchers could use this feature for various applications, including studying brain patterns, assessing cognitive states, or developing brain-computer interfaces (BCIs).

2. Data Visualization
   Functionality: By integrating libraries like matplotlib or pyqtgraph, users could visualize the EEG data in real-time, plotting voltage changes over time for each channel.
   Outcome: This would provide immediate feedback and insight into the brain activity, making it easier to understand brain responses to different stimuli or tasks.

3. Signal Processing
   Functionality: The code could implement signal processing techniques such as filtering, artifact removal, and feature extraction. Libraries like scipy and numpy would be useful for these tasks.
   Outcome: Improved data quality could lead to more accurate interpretations of brain activity. This would be critical for applications in clinical diagnostics or research where signal clarity is essential.

4. Event Detection
   Functionality: Users could write algorithms to detect specific brain wave patterns (e.g., alpha, beta, theta waves) or events like blinks or motor imagery.
   Outcome: This could enable the development of BCI applications that respond to user intent based on detected patterns, such as controlling devices or software using brain signals.

5. Data Storage and Analysis
   Functionality: The code could save the acquired data to files for later analysis, using formats like CSV or HDF5.
   Outcome: This would allow researchers to conduct offline analyses, enabling detailed studies and the potential to share datasets for collaborative research.

6. Integration with Machine Learning
   Functionality: The code could preprocess and format data for use in machine learning models, enabling the application of classifiers or regression techniques to predict cognitive states or actions based on brain activity.
   Outcome: This could lead to the creation of adaptive systems that learn from users’ brain activity, enhancing user interaction in various applications, from gaming to rehabilitation.

7. User-Friendly Interfaces
   Functionality: With frameworks like Tkinter or PyQt, the code could provide a graphical user interface (GUI) to facilitate interaction with the Cyton board, such as starting/stopping data acquisition and visualizing signals.
   Outcome: A more intuitive user experience could attract non-expert users and expand the usage of the OpenBCI system.

8. Community Contributions
   Functionality: The open-source nature of OpenBCI allows for community contributions. Other developers could build upon the code, adding features or optimizing performance.
   Outcome: A robust ecosystem of tools and applications could develop around the OpenBCI platform, fostering innovation and collaboration.

Conclusion
Creating Python code to connect to an OpenBCI Cyton Biosensing Board opens up numerous possibilities for experimentation, research, and development. The ease of access to real-time EEG data can empower users to explore the brain’s complexities and develop innovative applications in neuroscience, healthcare, and technology. However, it's essential to be mindful of ethical considerations and ensure that data is handled responsibly, especially when working with sensitive physiological information.

https://proatech.com/design/stepan/BioEraExamples20150313.zip
https://proatech.com/design/video_mp4.bpd
https://proatech.com/design/http_writer.bpd
https://proatech.com/design/fft2_row_matrix_float.bpd
https://proatech.com/design/vect_display_bar_color.bpd
https://proatech.com/design/openbci.bpd
https://proatech.com/design/openbci_noftdi.bpd
https://proatech.com/design/textstreamtoscalars.bpd
https://proatech.com/design/arduino_simulation.bpd
https://proatech.com/design/arduino_serial_console.bpd
https://proatech.com/design/textstreamtoscalars.bpd
https://proatech.com/design/xdf_read_annot.bpd
https://proatech.com/design/multigraph_main.bpd
https://proatech.com/design/multigraph_nested.bpd
https://proatech.com/design/midi_fade.bpd

I'm working on a BCI project that involves SMRs and I've elected to use the BCI2000 software package to observe Mu rhythms. I've a few questions:

• There are two OpenBCI source modules available in BCI2000: OpenBCISource and OpenBCI_module. After some guessing and checking, I've come to the conclusion that OpenBCISource is the right source module to use, but I'm left very curious as to what OpenBCI_module is for!
• After loading up BCI2000 w/ the OpenBCISource source module, conducting a few motor tasks and recording the resulting EEG data, I'm using the BCI2000 Offline Analysis tool to determine which electrodes/specta are highly correlated w/ the tasks and therefore optimal to use for that particular subject. What I noticed is that the Offline Analysis tool outputs a feature graph (electrodes and spectra) that has NINE channels; I'm left mystified since the Cyton board only has eight.

Thank you for your time and help!

I understand that brain-computer interfaces (BCI) cannot directly interpret specific thoughts. However, I'm interested in exploring ways to identify patterns in the EEG signals that could correlate with thinking about specific objects. Do you have any suggestions or insights on how I could approach this?" Note : i want to focus on the frontal regions like Fp1,Fz,Fp2 …ect .

if you can give me any open sources or datasets i will be appreciate !

So i became really interested in infra low training. Been doing NFB since 2013, ostly on myself and family. Have a few amps, one of them is a OpenBCI which should be able to go infra low since it is DC coupled. I know there is another thread in thus subforum, but i don't want to hijack it and want this thread to be more focused on ISF (Infra-Slow Ffluctuations). I know it is going to be mostly experimental and the method itself is proprietary. And i know that one should assume responsibility for negative effects this kind of training may entail.

Now, there is an article by the inventor of the method in which he uncovers some details. From reading that article, here is the gist of the method that i was able to distill:

• ISF uses a low-passed signal cut in the range at 0.002 to 0.012
• The filter being used is a 1st order butterworth with some special features.
• The low-passed signal is being compared with a dampened average trace of this same signal and when the original signal goes over or under the average signal the feedback sound is produced. Only two feedback sounds are used - for higher than average and for lower than average.
• Practitioner is to find the optimal reward frequency.

• There are several inhibits across the regular EEG spectrum for these bands: 1–3,
  4–7, 8–12, 12–15, 15–20, 20–30, and 30–40 Hz. Each is being inhibited at 3%.

• It's a bipolar montage. Although, when doing ISF one can combine bipolar ISF training with referential synchrony training.

It was very easy to create a design in BioEra that does just that - calculates the difference between averaged and original band-passed signal. One may then modulate feedback based on that difference - changing pitch of a tone, for example.

Here is the simplest form of what i was able to create in BioEra:

The difference signal looks like this:

I know that this is probably too naive to think that it could be so simple and that probably it is a bit more complicated in real life, but maybe there are those who have some experience and do their own variations of this training, i would like to ask a few questions:

• Is the filter choice correct?
• How do you calculate the average? A TimeTransform element in BioEra with Average or Long Average? Which averaging window?
• Should one compare the averaged and original band-passed signal or its amplitude in the expression evaluator?
• It is stated that electrode choice is crucial. Mine are Ag/AgCl sintered and i apply them through a cap with a gel. How can i check if i am getting the minimum necessary quality?

What do you guys think in general?

DataFilter.perform_bandpass (unprocessed_data, eeg_channels[i], BoardShim.get_sampling_rate (board_id), 4.0, 30.0, 4, (int)FilterTypes.BUTTERWORTH, 0.0);