bafaction

Forum Replies Created

Viewing 8 posts - 1 through 8 (of 8 total)
  • Author
    Posts
  • in reply to: Art Controller Adjustments #27345
    bafaction
    Participant

    Windell

    I had a chance to load this file. I have to adjust the clock cycle from 128 to 124 the times where a bit fast. I also had to adjust time C & D to be a bit longer. Otherwise it works perfectly and exactly they way I wanted.

    I don’t know how to thank you enough for helping me out

    Thanks once again

    in reply to: Art Controller Adjustments #27338
    bafaction
    Participant

    Thanks Heaps. I will Be testing the code this weekend. I had to wait to gain access to the art controller.

    I will let you know how it goes.

    Thanks heaps

    in reply to: Art Controller Adjustments #27256
    bafaction
    Participant

    Yes perfect. It should work fine like
    That

    Please make time C and E 0.3 seconds

    Thanks heaps.

    in reply to: Art Controller Adjustments #27252
    bafaction
    Participant

    (A) Yes the par time/run time is what it set by the dip switches

    (B) Yes as this is how long I would like the PB3 to run for. It does not have to be adjusted via any external means. If it can be a part of the program only.

    Please let me know if you need more information.

    in reply to: Art Controller Adjustments #27248
    bafaction
    Participant

    Hope I can make sense with this.

    Par Time = Run time
    Delay Time = Amount of time before the Par Time/Run Time starts

    Let go back to the basic program without the 3 second delay.

    I set say 5 seconds par/run time using the dip switches.
    I activate the trigger input via an external Momentary Push Switch
    This then starts the Par time/Run time for PB4 to go high for 5 secs

    Below is the sequence of events

    1) Activate trigger wait 3 seconds (Delay Time) before starting the Par
    time/Run time
    2) Once Par Time/Run Time Starts we activate PB4 high and stays high for the
    entire Par Time/Run Time
    3) Once Par Time/Run Time Starts we activate PB3 High for a total run time of
    0.3-0.5 seconds max then PB3 goes low.
    4) End of the Par Time/Run Time PB4 goes Low
    5) PB3 to go high 0.2 secs before PB4 goes low and stays high for a
    further 0.2 – 0.3 seconds then goes low.
    6) Wait for Next Trigger to start the sequence again.

    • This reply was modified 4 years, 10 months ago by bafaction.
    in reply to: Art Controller Adjustments #27241
    bafaction
    Participant

    Windell the 3 sec hack worked. I have been using that for the past 6 years.

    1- yes please make it a output

    2- 3 Sec Delay works perfectly with the adjusted program

    3- Yes at the start of the programed par time

    4- Yes for 0.3 – 0.5 sec max

    5- Yes

    6- No. I would like the PB3 and PB4 to both start at the programmed par time

    7- Well Kinda. I would like the the PB3 high 0.2 before PB4 goes low (par time ends) and stay high for a further 0.1 (Total time high 0.3 max 0.5)

    8- Yes see my point 7

    9- Yes

    I hope this now makes more sense.

    Appreciate your help

    in reply to: Art Controller Adjustments #27230
    bafaction
    Participant

    The only part that was changed is below.

    if (PINB & 1) // Make sure that cancel pin is HIGH (not active):

    {
    resetTimer();
    StopTime = 3;
    while ( seconds() < StopTime)
    {}
    resetTimer();
    StopTime = calculateStopTime();
    TurnCoilOn();
    Triggered = 1;
    CoilOn = 1;
    }

    I was advised by someone on this forum 6 years ago in how to change this.

    in reply to: Art Controller Adjustments #27224
    bafaction
    Participant

    I am using the relay to control a solenoid for a locking mechanism or a target face time for some target shooting events. One of the events requires a start and stop buzzer.

    I had the original Art Controller file changed to give me a 3 sec delay when the start button has been pressed before the delay time is active. (Below is a copy of adjusted file) I have set up the delay time adjusts via a rotary binary switch. This allows me to select from 3 seconds up to 15 seconds delay time.

    What I am trying to achieve is having another output from the art controller such as i/o PB3 to drive an external relay board which will activate the buzzer, But this relay drive has to be at the start of the delay time and at the end of the delay time and run for about half a second.

    I hope this makes sense

    /*
    Title: artcon.c
    Author: Windell H. Oskay
    Date Created: 7/16/12
    Last Modified: 9/13/12

    the Art Controller relay board
    Release version 1.0

    Product info:
    http://evilmadscience.com/productsmenu/tinykitlist/580

    Documentation:
    http://wiki.evilmadscience.com/Art_Controller

    Target: Atmel ATtiny2313A MCU

    Fuse configuration:
    Use 8 MHz internal RC oscillator, with divide-by-8 clock prescaler: 1 MHz clock
    BOD active at 2.7 V.

    Fuses: -U lfuse:w:0x64:m -U hfuse:w:0xdb:m -U efuse:w:0xff:m

    ————————————————-
    USAGE: How to compile and install

    A makefile is provided to compile and install this program using AVR-GCC and avrdude.

    To use it, follow these steps:
    1. Update the header of the makefile as needed to reflect the type of AVR programmer that you use.
    2. Open a terminal window and move into the directory with this file and the makefile.
    3. At the terminal enter
    make clean <return>
    make all <return>
    make install <return>
    4. Make sure that avrdude does not report any errors. If all goes well, the last few lines output by avrdude
    should look something like this:

    avrdude: verifying …
    avrdude: XXXX bytes of flash verified

    avrdude: safemode: lfuse reads as 64
    avrdude: safemode: hfuse reads as DB
    avrdude: safemode: efuse reads as FF
    avrdude: safemode: Fuses OK

    avrdude done. Thank you.

    If you a different programming environment, make sure that you copy over the fuse settings from the makefile.

    */

    /*

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

    */

    #include <avr/io.h> // device specific I/O definitions
    #include <avr/interrupt.h>

    // System clock : 1 MHz
    // Set compare to once every 124 cycles– so every 124 microseconds
    #define MICROSECONDS_PER_COMPARE 124

    #define TurnCoilOn(); PORTB |= 16;
    #define TurnCoilOff(); PORTB &= 239;

    // Inputs: PA0, PA1
    #define InputMaskA 3

    // Inputs: PB0 – PB3
    #define InputMaskB 15

    // Inputs: PD0 – PD6
    #define InputMaskD 127

    //volatile variables: ones that may be modified in an ISR
    volatile unsigned int timer0_microseconds;
    volatile unsigned int timer0_millis;
    volatile unsigned long timer0_seconds;

    // Note: Seconds (timer0_seconds) will not overflow in realistic time periods.
    // Maximum unsigned long is 2^32 – 1, or 4 294 967 295
    // 4 294 967 295 seconds, or about 136 years.

    unsigned long millis(void)
    { // Return total milliseconds ***since last timer reset***
    // Will roll over after 49 days.

    unsigned int mills;
    unsigned long secs;
    uint8_t oldSREG = SREG;

    // disable interrupts while we read timer values or we might get an
    // inconsistent value
    cli();
    mills = timer0_millis;
    secs = timer0_seconds;
    SREG = oldSREG;

    secs = 1000 * secs + mills;

    return secs;
    }

    unsigned long seconds(void)
    {
    unsigned long m;
    uint8_t oldSREG = SREG;

    // disable interrupts while we read timer0_seconds or we might get an
    // inconsistent value (e.g. in the middle of a write to timer0_seconds)
    cli();
    m = timer0_seconds;
    SREG = oldSREG;

    return m;
    }

    void resetTimer(void)
    {
    uint8_t oldSREG = SREG;
    cli();

    // disable interrupts to avoid possible
    // inconsistent values (e.g. in the middle of a write to timer0_millis)

    timer0_microseconds = 0;
    timer0_millis = 0;
    timer0_seconds = 0;

    SREG = oldSREG;
    return;
    }

    unsigned long calculateStopTime (void)
    {
    unsigned long total = 0;
    unsigned int temp = 1;

    if ((PIND & _BV(5)) == 0)
    total = 1;
    if ((PIND & _BV(4))== 0)
    total += 2;
    if ((PIND & _BV(3)) == 0)
    total += 4;
    if ((PIND & _BV(2)) == 0)
    total += 8;
    if ((PINA & _BV(0)) == 0)
    total += 16;

    if (total == 0)
    total = 1;

    if ((PINA & _BV(1))== 0)
    temp *= 6;
    if ((PIND & _BV(1))== 0)
    temp *= 10;
    if ((PIND & _BV(0))== 0)
    temp *= 60;

    return total * temp;
    }

    int main (void)
    {
    unsigned long StopTime;
    unsigned long debounceStartTime;

    uint8_t Triggered;
    uint8_t CoilOn;
    uint8_t doCancel;
    uint8_t debounced;
    uint8_t TrigInLast;
    uint8_t TrigIn;

    DDRA = 0;
    DDRB = _BV(4); // Set line B4 to be an output, the rest are inputs.
    DDRD = 0;

    // Pull-ups on inputs:
    PORTA = InputMaskA;
    PORTB = InputMaskB;
    PORTD = InputMaskD;

    CLKPR = (1 << CLKPCE); // enable clock prescaler update
    CLKPR = 0; // set clock to maximum

    WDTCSR = 0x00; // disable watchdog timer

    // Set up the timer interrupt:

    TCCR0A = 2;
    OCR0A = 128;

    TIFR = (1 << TOV0); // clear interrupt flag
    TIMSK = (1 << OCIE0A); // enable compare interrupt
    TCCR0B = (1 << CS01); // start timer, prescale by 8

    asm(“sei”); // ENABLE global interrupts

    uint8_t pinbCopy = PINB;

    resetTimer();
    StopTime = calculateStopTime();

    if ((pinbCopy & 1) && ((pinbCopy & 2) == 0)) {
    // If Cancel is false (b0 is high) and trigger at reset is true (B1 is low), trigger… Now!
    TurnCoilOn();
    Triggered = 1;
    CoilOn = 1;

    }
    else
    {
    TurnCoilOff();
    Triggered = 0;
    CoilOn = 0;
    }

    debounced = 0;
    debounceStartTime = 0;

    TrigInLast = ((PIND & _BV(6)) == 0);

    for (;;) { // main loop

    TrigIn = ((PIND & _BV(6)) == 0); // 1 if trigger input is asserted (trigger pin is grounded). Zero otherwise.
    doCancel = 0;

    if ( TrigIn && (TrigInLast == 0) && (debounced > 1))
    { // Legitimate button press/input signal detected.

    // Check for new trigger:
    if (Triggered == 0)
    {
    if (PINB & 1) // Make sure that cancel pin is HIGH (not active):
    {
    resetTimer();
    StopTime = 3;
    while ( seconds () < StopTime)
    {}
    resetTimer();
    StopTime = calculateStopTime();
    TurnCoilOn();
    Triggered = 1;
    CoilOn = 1;
    }
    }
    else if ((PINB & _BV(2)) == 0) // If start/stop on trig is selected (low)
    {
    doCancel = 1;
    }
    }

    if ( TrigIn == 0 ){
    if (TrigInLast) // Trig in button/signal just released
    {
    debounceStartTime = millis();
    debounced = 1; // Intermediate Step
    }
    else
    {
    if ((millis() – debounceStartTime) > 50) // Trigger input released for 50 ms: “released”
    {
    debounced = 2; // Debouncing routine complete.
    }

    }
    }

    if (TrigIn)
    { //Input is asserted; reset debounce counter.
    debounced = 0;
    }

    if (Triggered)
    {

    if ((PINB & _BV(0)) == 0) // If Cancel signal is asserted…
    {
    doCancel = 1;
    }

    if (seconds() >= StopTime) { // If time has run out
    if (PINB & _BV(3))
    { // Repeat mode is off.
    doCancel = 1;
    }
    else
    {
    // Repeat mode is ON; begin the next part of the cycle.
    resetTimer();
    StopTime = calculateStopTime();

    if (CoilOn) {
    TurnCoilOff();
    CoilOn = 0;
    }
    else {
    TurnCoilOn();
    CoilOn = 1;
    }
    }
    }

    if (doCancel)
    {
    TurnCoilOff();
    Triggered = 0;
    CoilOn = 0;
    }
    }

    TrigInLast = TrigIn;

    } //End main loop
    return 0;
    }

    SIGNAL (TIMER0_COMPA_vect) {
    timer0_microseconds += MICROSECONDS_PER_COMPARE;
    if (timer0_microseconds > 1000) {
    timer0_millis++;
    timer0_microseconds -= 1000;

    if (timer0_millis > 1000) {
    timer0_seconds++;
    timer0_millis -= 1000;
    }
    }

    }

Viewing 8 posts - 1 through 8 (of 8 total)