static bool Running_State_Code(void * pObject, oosmos_sRegion * pRegion, const oosmos_sEvent * pEvent)
{
matrix * pMatrix = (matrix *) pObject;
switch (pEvent->Code) {
case oosmos_INSTATE:
oosmos_SyncBegin(pRegion);
while (true) {
for (pMatrix->m_CurrentRowIndex = 0; pMatrix->m_CurrentRowIndex < pMatrix->m_Rows; pMatrix->m_CurrentRowIndex++) {
if (pMatrix->m_pRowPins[pMatrix->m_CurrentRowIndex] == NULL)
continue;
pinOn(pMatrix->m_pRowPins[pMatrix->m_CurrentRowIndex]);
oosmos_SyncDelayMS(pRegion, RowOnSettleTimeUS);
InterrogateColumns(pMatrix);
pinOff(pMatrix->m_pRowPins[pMatrix->m_CurrentRowIndex]);
oosmos_SyncDelayMS(pRegion, RowOffSettleTimeUS);
}
}
oosmos_SyncEnd(pRegion);
return true;
}
return false;
}
/**
Enable a stepper motor.
@param stepper Which stepper (0 or 1).
\b Example
\code
// enable stepper 1
stepperEnable(1);
\endcode
*/
void stepperEnable(int stepper)
{
fasttimerInit(2);
Stepper* s = &steppers[stepper];
pwmEnableChannel(stepper * 2);
pwmEnableChannel(stepper * 2 + 1);
// Fire the PWM's up
s->duty = 1023;
int pwm = stepper * 2;
pwmSetDuty(pwm, s->duty);
pwmSetDuty(pwm + 1, s->duty);
// Get IO's
int i;
for (i = 0; i < 4; i++) {
s->pins[i] = stepperGetIo(stepper, i);
pinSetMode(s->pins[i], OUTPUT);
pinOn(s->pins[i]);
}
s->position = 0;
s->destination = 0;
s->speed = STEPPER_DEFAULT_SPEED;
s->timerRunning = 0;
s->halfStep = false;
s->bipolar = true;
s->fastTimer.handler = stepperIRQCallback;
s->fastTimer.id = stepper;
fasttimerStart(&s->fastTimer, s->speed * 1000, true);
}
void allOn()
{
int i;
for (i = 0; i < TOTAL_PINS; i++) {
pinOn(i);
}
}
static void Write4(lcd * pLCD, const uint8_t Value)
{
(Value & 1 ? pinOn : pinOff)(pLCD->m_pData4);
(Value & 2 ? pinOn : pinOff)(pLCD->m_pData5);
(Value & 4 ? pinOn : pinOff)(pLCD->m_pData6);
(Value & 8 ? pinOn : pinOff)(pLCD->m_pData7);
pinOn(pLCD->m_pE);
oosmos_DelayUS(1);
pinOff(pLCD->m_pE);
}
static void SetMode(lcd * pLCD, const eMode Mode)
{
switch (Mode) {
case modeWriteCommand:
pinOff(pLCD->m_pRS);
if (pLCD->m_pRW != NULL) pinOff(pLCD->m_pRW);
break;
case modeWriteData:
pinOn(pLCD->m_pRS);
if (pLCD->m_pRW != NULL) pinOff(pLCD->m_pRW);
break;
case modeReadStatus:
pinOff(pLCD->m_pRS);
if (pLCD->m_pRW != NULL) pinOn(pLCD->m_pRW);
break;
case modeReadData:
pinOn(pLCD->m_pRS);
if (pLCD->m_pRW != NULL) pinOn(pLCD->m_pRW);
break;
}
}
int main (void)
{
// Set up the switch and callback function
int_sw sw = int_sw(SW_PIN, &toggleLED);
// Configure the LED_PIN as an output
pinOutput(LED_PIN);
pinOn(LED_PIN);
// Already done by clock library, but enable interrupts again anyway
_EINT();
// Enter low power mode 3
LPM3;
}
// beep for a quarter of a second
void beep(void) {
outputs(pin(0) | pin(1));
pinOff(1);
byte i = 0;
while (i < 250) {
delay(1);
pinOn(pin(0));
delay(1);
pinOff(pin(0));
i++;
}
}
int main() {
// Setup the comparator
becomeInput(0);
becomeInput(1);
pinOff(0);
pinOff(1);
// Setup our outputs
becomeOutput(2);
becomeOutput(3);
becomeOutput(4);
// Not using this, it's the reset pin!
//becomeOutput(5);
// Todo: See if the internal bandgap is a good enough voltage for comparator
// Magic analog comparator configuration voodoo:
// ACD=0, ACBG=0, ACO=0 ACI=0 ACIE=0 ACIC=0 ACIS1, ACIS0
// - interrupt on output toggle
ACSR = 0b00000000;
// ADEN=1
ADCSRA = 0b10000000;
// ACME=0 (on) ADEN=0 MUX = b000 for use of AIN1
ADCSRB = 0b00000000;
// Save some power by turning off the digital input on AIN0 and AIN1
DIDR0 = 0b00111100;
// Voodoo done.
// Do a little dance!
unsigned char output = first_output;
unsigned long gap = 0;
while(true) {
//gap = pollComparatorUntil(false); // wait till the thingy goes low (i.e. pulse done!)
gap = pollComparatorUntil(true); // wait till it does high, and then...
if (output <= max_output) pinOff(output); // turn off the last servo
output++; // change to the next one
if (gap > reset_gap_minimum) {
output = first_output;
}
// Pop the new Servo's signal on!
if (output <= max_output) pinOn(output);
}
return 0;
}
void servoTimerEvent()
{
//mPORTDToggleBits(BIT_3);
//StartCritical();
stopServos();
int j;
switch(servoStateMachineCurrentState){
case LOW:
updateAllEncoders();
if(getRunPidIsr()){
RunPIDControl();
//Print_Level l = getPrintLevel();
interpolateZXY();
//setPrintLevelNoPrint();
}
//runLinearInterpolationServo(start,stop);
runSort();
for (j=0;j<NUM_SERVO;j++){
pinOn(j);
}
lastValue = 0;
sortedIndex=0;
//1ms delay for all servos
setTimerPreTime();
return;
case PRETIME:
if(setUpNextServo())
return;
case TIME:
stopCurrentServo();
if(servoStateMachineCurrentState == TIME){
if(setUpNextServo() == false) {
//fast stop for channels with the same value
servoTimerEvent();
}
}
//If there are still more channels to be turned off after the recoursion, break
if(servoStateMachineCurrentState != FINISH)
return;
case FINISH:
setTimerLowTime();
return;
}
//EndCritical();
}
void midi_process(snd_seq_event_t *ev)
{
// If this event is a PGMCHANGE type, it's a request to map a channel to an instrument
if (ev->type == SND_SEQ_EVENT_PGMCHANGE) {
//printf("PGMCHANGE: channel %2d, %5d, %5d\n", ev->data.control.channel, ev->data.control.param, ev->data.control.value);
// Clear pins state, this is probably the beginning of a new song
allOff();
}
// If the event is SND_SEQ_EVENT_BOUNCE, then maybe this is an interrupt?
if (ev->type == SND_SEQ_EVENT_BOUNCE) {
allOff();
}
if (channelActive == ev->data.control.channel) {
// Note on/off event
if (ev->type == SND_SEQ_EVENT_NOTEON) {
// When pinActive is -1, we're playing the first note
if (-1 == pinActive) {
pinActive = 0;
} else {
// First turn off the current pin
printf("Turning off pin %d\n", pinActive);
pinOff(pinActive);
// Increment pinActive
printf("Incrementing pinActive\n");
pinActive++;
// Reset to zero if we're above the number of pins
if (pinActive >= TOTAL_PINS) {
printf("Resetting pinActive to zero\n");
pinActive = 0;
}
}
// Turn on the next pin
printf("Turning on pin %d\n", pinActive);
pinOn(pinActive);
}
}
snd_seq_free_event(ev);
}
int main(void)
{
basic_clock clock = basic_clock();
spi spi_test = spi(SPI_B0);
pinOutput(LED_PIN);
pinOutput(LED_PIN2);
pinOn(LED_PIN2);
for (;;) //ever
{
for (uint8_t i=0; i<255; i++)
{
spi_test.write(i);
}
pinToggle(LED_PIN);
pinToggle(LED_PIN2);
_delay_s(1);
}
}
int main(void)
{
basic_clock clock = basic_clock(DCO_F_1MHz);
tlc5925 tlc = tlc5925(p1_4);
pinOutput(LED_PIN);
pinOutput(LED_PIN2);
pinOn(LED_PIN2);
tlc.write((uint16_t)TLC5925_CH01);
_delay_s(2);
tlc.write((uint16_t)TLC5925_CH0_15);
_delay_s(5);
for (;;) //ever
{
tlc.shiftDown(16,TLC5925_CH00);
pinToggle(LED_PIN);
pinToggle(LED_PIN2);
_delay_s(1);
}
}
void servoTimerEvent()
{
//int flag = FlagBusy_IO;
if(blockIndex>=dataTableSize){
println_E("Bad block size");
return;
}
switch(servoStateMachineCurrentState){
case STARTLOOP:
FlagBusy_IO=1;
pinOn( blockIndex );
servoStateMachineCurrentState = BON;
OCR1A = blockData[blockIndex].toBON;
break;
case BON:
pinOn( blockIndex + 12 );
servoStateMachineCurrentState =AOFF;
OCR1A = blockData[blockIndex].toAOFF;
break;
case AOFF:
pinOff(blockIndex );
servoStateMachineCurrentState = FINISH;
OCR1A = blockData[blockIndex].toFINISH;
break;
case FINISH:
pinOff(blockIndex + 12 );
//UART is now clear to send while timers are re-calculated and the server is run
FlagBusy_IO=0;
EndCritical();
TCCR1Bbits._CS=0;// stop the clock
//If block is now done, reset the block index and sort
blockIndex++;
if(blockIndex == dataTableSize){
// this resets the block Index
blockIndex=0;
}
updateTimer(TCNT1);
TCNT1=0;// Start from zero for each pulse section
currentTimer = 0;
updateServoValues();
servoStateMachineCurrentState = STARTLOOP;
blockData[blockIndex].toBON = calcTimer ( LOOPSPACING+LOOPPERIOD - ( OFFSET+blockData[blockIndex].positionTempB) );
blockData[blockIndex].toAOFF= calcTimer ( LOOPSPACING+ OFFSET+blockData[blockIndex].positionTempA );
blockData[blockIndex].toFINISH= calcTimer ( LOOPSPACING+LOOPPERIOD );
setServoTimer( LOOPSPACING);
TCCR1Bbits._CS = 2;// value CLslk I/O/8 (From prescaler)
break;
}
//FlagBusy_IO=flag;
}
