fork/GramFirmware

git clone https://git.julia.blue/fork/GramFirmware

CarVacrebase to configurator818d962

gram
7.4 KiB189 linesraw
1#include "comms/GamecubeBackend.hpp"
2
3#include "core/ControllerMode.hpp"
4#include "core/InputSource.hpp"
5
6#include <Nintendo.h>
7
8GamecubeBackend::GamecubeBackend(
9    InputState &inputs,
10    InputSource **input_sources,
11    size_t input_source_count,
12    int polling_rate,
13    int data_pin
14)
15    : CommunicationBackend(inputs, input_sources, input_source_count),
16      _gamecube(data_pin) {
17    _data = defaultGamecubeData;
18
19    /*
20    if (polling_rate > 0) {
21        // Delay used between input updates to postpone them until right before the
22        // next poll, while also leaving time (850us) for processing to finish.
23        _delay = (1000000 / polling_rate) - 850;
24    } else {
25        // If polling rate is set to 0, disable the delay.
26        _delay = 0;
27    }
28    */
29    _delay = 0;
30
31    //Set up hardware timer
32    TCCR1A = 0;
33    TCCR1B = (1 << CS11) | (1 << CS10);//64 clock divider -> 4 microsecond resolution
34    zeroTcnt1();
35}
36
37CommunicationBackendId GamecubeBackend::BackendId() {
38    return COMMS_BACKEND_GAMECUBE;
39}
40
41void GamecubeBackend::SendReport() {
42    static bool status = false;//true = normal poll
43    static uint32_t minLoop = 16384;
44    static uint loopCount = 0;
45    static bool detect = true;//false means run
46    static uint sampleCount = 1;
47    static uint sampleSpacing = 0;
48    static uint16_t loopTime = 0;
49    const uint fastestLoop = 975; //fastest possible loop; platform-dependent
50    //const uint fastestLoop = 450; //fastest possible loop; platform-dependent
51
52    //read how long this loop took
53    loopTime = readTcnt1();//each unit is 4 microseconds
54    //zero the counter so that it doesn't overflow
55    zeroTcnt1();
56
57    if(detect && status) {
58        //run loop time detection procedure
59#ifdef TIMINGDEBUG
60        digitalWrite(21, HIGH);
61#endif
62        loopCount++;
63        if(loopCount > 5 && loopTime > 300/4) {//screen out implausibly fast samples; the limit is 2500 Hz (400 us) so we use 300 us as the limit, ignore first few polls
64            minLoop = min(minLoop, loopTime);
65        }
66        if(loopCount >= 100) {
67            detect = false;
68            sampleCount = 1;
69            while(1000/4*sampleCount <= minLoop) {//we want [sampleCount] ms-spaced samples within the smallest possible loop
70                sampleCount++;
71            }
72            sampleSpacing = minLoop / sampleCount;
73            if(sampleSpacing < (fastestLoop/4) && sampleCount > 1) {
74                sampleCount--;
75                sampleSpacing = minLoop / sampleCount;
76            }
77        }
78        // Make sure to respond while measuring.
79        ScanInputs();
80
81        // Run gamemode logic.
82        UpdateOutputs();
83
84        // Digital outputs
85        _data.report.a = _outputs.a;
86        _data.report.b = _outputs.b;
87        _data.report.x = _outputs.x;
88        _data.report.y = _outputs.y;
89        _data.report.z = _outputs.buttonR;
90        _data.report.l = _outputs.triggerLDigital;
91        _data.report.r = _outputs.triggerRDigital;
92        _data.report.start = _outputs.start;
93        _data.report.dleft = _outputs.dpadLeft | _outputs.select;
94        _data.report.dright = _outputs.dpadRight | _outputs.home;
95        _data.report.ddown = _outputs.dpadDown;
96        _data.report.dup = _outputs.dpadUp;
97
98        // Analog outputs
99        _data.report.xAxis = _outputs.leftStickX;
100        _data.report.yAxis = _outputs.leftStickY;
101        _data.report.cxAxis = _outputs.rightStickX;
102        _data.report.cyAxis = _outputs.rightStickY;
103        _data.report.left = _outputs.triggerLAnalog + 31;
104        _data.report.right = _outputs.triggerRAnalog + 31;
105    } else {
106        if(loopTime > minLoop+(minLoop >> 1)) {//if the loop time is 50% longer than expected
107            detect = true;//stop scanning inputs briefly and re-measure timings
108            loopCount = 0;
109            sampleCount = 1;
110            sampleSpacing = 0;
111            loopTime = 0;
112        }
113        //run the delay procedure based on samplespacing
114        //in the stock arduino software, it samples 850 us after the end of the poll response
115        //we want the last sample to begin [850 + extra computation time] before the beginning of the last poll to give room for the sample and the travel time+nerf computation
116        //
117        for (uint i = 0; i < sampleCount; i++) {
118
119            const uint16_t nerfTime = 250/4;
120            const uint16_t computationTime = 700/4 + nerfTime;//*_nerfOn;//depends on the platform; 4us steps.
121            //700 microseconds is sufficient with no travel time computation
122            const uint16_t targetTime = ((i+1)*sampleSpacing)-computationTime;
123            //const uint16_t targetTime = i*sampleSpacing;
124            int count = 0;
125            while(readTcnt1() < targetTime) {
126                count++;//do something?
127                //spinlock
128            }
129
130            ScanInputs();
131
132            // Run gamemode logic.
133            UpdateOutputs();
134
135            //if(_nerfOn) {
136            if(_gamemode->isMelee()) {
137                //APPLY NERFS HERE
138                OutputState nerfedOutputs;
139                limitOutputs(sampleSpacing, _nerfOn ? AB_A : AB_B, _inputs, _outputs, nerfedOutputs);
140                // Digital outputs
141                _data.report.a = nerfedOutputs.a;
142                _data.report.b = nerfedOutputs.b;
143                _data.report.x = nerfedOutputs.x;
144                _data.report.y = nerfedOutputs.y;
145                _data.report.z = nerfedOutputs.buttonR;
146                _data.report.l = nerfedOutputs.triggerLDigital;
147                _data.report.r = nerfedOutputs.triggerRDigital;
148                _data.report.start = nerfedOutputs.start;
149                _data.report.dleft = nerfedOutputs.dpadLeft | nerfedOutputs.select;
150                _data.report.dright = nerfedOutputs.dpadRight | nerfedOutputs.home;
151                _data.report.ddown = nerfedOutputs.dpadDown;
152                _data.report.dup = nerfedOutputs.dpadUp;
153
154                // Analog outputs
155                _data.report.xAxis = nerfedOutputs.leftStickX;
156                _data.report.yAxis = nerfedOutputs.leftStickY;
157                _data.report.cxAxis = nerfedOutputs.rightStickX;
158                _data.report.cyAxis = nerfedOutputs.rightStickY;
159                _data.report.left = nerfedOutputs.triggerLAnalog + 31;
160                _data.report.right = nerfedOutputs.triggerRAnalog + 31;
161            } else {
162                // Digital outputs
163                _data.report.a = _outputs.a;
164                _data.report.b = _outputs.b;
165                _data.report.x = _outputs.x;
166                _data.report.y = _outputs.y;
167                _data.report.z = _outputs.buttonR;
168                _data.report.l = _outputs.triggerLDigital;
169                _data.report.r = _outputs.triggerRDigital;
170                _data.report.start = _outputs.start;
171                _data.report.dleft = _outputs.dpadLeft | _outputs.select;
172                _data.report.dright = _outputs.dpadRight | _outputs.home;
173                _data.report.ddown = _outputs.dpadDown;
174                _data.report.dup = _outputs.dpadUp;
175
176                // Analog outputs
177                _data.report.xAxis = _outputs.leftStickX;
178                _data.report.yAxis = _outputs.leftStickY;
179                _data.report.cxAxis = _outputs.rightStickX;
180                _data.report.cyAxis = _outputs.rightStickY;
181                _data.report.left = _outputs.triggerLAnalog + 31;
182                _data.report.right = _outputs.triggerRAnalog + 31;
183            }
184        }
185    }
186
187    // Send outputs to console.
188    status = _gamecube->write(_data);
189}