Pewnie dla Was, mistrzów programowania nie będzie problemu w stwierdzeniu co źle zrobiłem i nakierowania mnie na właściwy tor 
za co z góry dziękuję.
Poniżej kod
[syntax=c]/*
/* ----------------------- AVR includes -------------------------------------*/
#include "avr/io.h"
#include "avr/interrupt.h"
#include <util/delay.h>
/* ----------------------- Modbus includes ----------------------------------*/
#include "mb.h"
#include "mbport.h"
/* ----------------------- Defines ------------------------------------------*/
#define REG_HOLDING_START 1000
#define REG_HOLDING_NREGS 16
#define REG_INPUT_START 1000
#define REG_INPUT_NREGS 0
/*********************** D I M M E R - U S T A W I E N I A ***************************/
#define LICZBA_KROKOW 200
// czas trwania szpilki (Detekcja ZERA) wyrażony w milisekundach np: 1,2,... albo np: 0.5
#define SZPILKA_MS 1.8
/*********************** D I M M E R - U S T A W I E N I A ***************************/
#define __OCR_STEP ((F_CPU/8)*((1000-((SZPILKA_MS*100)/2))/LICZBA_KROKOW))/100000
//#define procent(x) ((x*(LICZBA_KROKOW-1))/100)
static uint8_t procent(uint8_t pr)
{
return (pr * (LICZBA_KROKOW-1))/100;
}
/* ----------------------- Static variables ---------------------------------*/
static USHORT usRegHoldingStart = REG_HOLDING_START;
static USHORT usRegHoldingBuf[REG_HOLDING_NREGS];
static USHORT usRegInputStart = REG_INPUT_START;
static USHORT usRegInputBuf[REG_INPUT_NREGS];
#define T_ZAR1_ON PORTC |= (1<<PC0)
#define T_ZAR1_OFF PORTC &= ~(1<<PC0)
#define T_ZAR2_ON PORTC |= (1<<PC1)
#define T_ZAR2_OFF PORTC &= ~(1<<PC1)
#define T_ZAR3_ON PORTC |= (1<<PC2)
#define T_ZAR3_OFF PORTC &= ~(1<<PC2)
#define T_ZAR4_ON PORTC |= (1<<PC3)
#define T_ZAR4_OFF PORTC &= ~(1<<PC3)
#define T_ZAR5_ON PORTC |= (1<<PC4)
#define T_ZAR5_OFF PORTC &= ~(1<<PC4)
#define T_ZAR6_ON PORTC |= (1<<PC5)
#define T_ZAR6_OFF PORTC &= ~(1<<PC5)
#define T_ZAR7_ON PORTC |= (1<<PC6)
#define T_ZAR7_OFF PORTC &= ~(1<<PC6)
#define T_ZAR8_ON PORTC |= (1<<PC7)
#define T_ZAR8_OFF PORTC &= ~(1<<PC7)
#define T_ZAR9_ON PORTA |= (1<<PA0)
#define T_ZAR9_OFF PORTA &= ~(1<<PA0)
#define T_ZAR10_ON PORTA |= (1<<PA1)
#define T_ZAR10_OFF PORTA &= ~(1<<PA1)
#define T_ZAR11_ON PORTA |= (1<<PA2)
#define T_ZAR11_OFF PORTA &= ~(1<<PA2)
#define T_ZAR12_ON PORTA |= (1<<PA3)
#define T_ZAR12_OFF PORTA &= ~(1<<PA3)
#define T_ZAR13_ON PORTA |= (1<<PA4)
#define T_ZAR13_OFF PORTA &= ~(1<<PA4)
#define T_ZAR14_ON PORTA |= (1<<PA5)
#define T_ZAR14_OFF PORTA &= ~(1<<PA5)
#define T_ZAR15_ON PORTA |= (1<<PA6)
#define T_ZAR15_OFF PORTA &= ~(1<<PA6)
#define T_ZAR16_ON PORTA |= (1<<PA7)
#define T_ZAR16_OFF PORTA &= ~(1<<PA7)
volatile uint8_t kroki;
volatile uint8_t kanal1, kanal2, kanal3, kanal4, kanal5, kanal6, kanal7, kanal8, kanal9, kanal10, kanal11, kanal12, kanal13, kanal14, kanal15, kanal16;
volatile uint8_t za1, za2, za3, za4, za5, za6, za7, za8, za9, za10, za11, za12, za13, za14, za15, za16;
volatile uint8_t ika1;
int
main( void )
{
DDRC |= (1<<PC0);
T_ZAR1_OFF;
DDRC |= (1<<PC1);
T_ZAR2_OFF;
DDRC |= (1<<PC2);
T_ZAR3_OFF;
DDRC |= (1<<PC3);
T_ZAR4_OFF;
DDRC |= (1<<PC4);
T_ZAR5_OFF;
DDRC |= (1<<PC5);
T_ZAR6_OFF;
DDRC |= (1<<PC6);
T_ZAR7_OFF;
DDRC |= (1<<PC7);
T_ZAR8_OFF;
DDRC |= (1<<PA0);
T_ZAR9_OFF;
DDRC |= (1<<PA1);
T_ZAR10_OFF;
DDRC |= (1<<PA2);
T_ZAR11_OFF;
DDRC |= (1<<PA3);
T_ZAR12_OFF;
DDRC |= (1<<PA4);
T_ZAR13_OFF;
DDRC |= (1<<PA5);
T_ZAR14_OFF;
DDRC |= (1<<PA6);
T_ZAR15_OFF;
DDRC |= (1<<PA7);
T_ZAR16_OFF;
// Przerwanie INT0
MCUCR |= (1<<ISC01)|(1<<ISC00);// zbocze narastające
GICR |= (1<<INT0);// odblokowanie INT0
// TIMER2
#define TIMER2_START TCCR2 |= (1<<CS21)// prescaler=8
#define TIMER2_STOP TCCR2 &= ~(1<<CS21)// prescaler off
TCCR2 |= (1<<WGM21);// tryb CTC
TIMSK |= (1<<OCIE2);// odblokowanie przerwania COMPARE MATCH
OCR2 = __OCR_STEP;
const UCHAR ucSlaveID[] = { 0xAA, 0xBB, 0xCC };
eMBErrorCode eStatus;
eStatus = eMBInit( MB_RTU, 0x1, 0, 9600, MB_PAR_NONE );
eStatus = eMBSetSlaveID( 0x34, TRUE, ucSlaveID, 3 );
sei( );
#define szybkosc 30
/* Enable the Modbus Protocol Stack. */
eStatus = eMBEnable( );
for( ;; )
{
uint8_t a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p;
/* ----------------------- Żarówka 1 ----------------------------------*/
if( a<za1)
{
for( a=kanal1; a<za1; a++)
{
kanal1 = procent(a);
_delay_ms(szybkosc);
}
}
if( a>za1)
{
for( a=kanal1; a>za1; a--)
{
kanal1 = procent(a);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 2 ----------------------------------*/
if( b<za2)
{
for( b=kanal2; b<za2; b++)
{
kanal2 = procent(b);
_delay_ms(szybkosc);
}
}
if( b>za2)
{
for( b=kanal2; b>za2; b--)
{
kanal2 = procent(b);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 3 ----------------------------------*/
if( c<za3)
{
for( c=kanal3; c<za3; c++)
{
kanal3 = procent(c);
_delay_ms(szybkosc);
}
}
if( c>za3)
{
for( c=kanal3; c>za3; c--)
{
kanal3 = procent(c);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 4 ----------------------------------*/
if( d<za4)
{
for( d=kanal4; d<za4; d++)
{
kanal4 = procent(d);
_delay_ms(szybkosc);
}
}
if( d>za4)
{
for( d=kanal4; d>za4; d--)
{
kanal4 = procent(d);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 5 ----------------------------------*/
if( e<za5)
{
for( e=kanal5; e<za5; e++)
{
kanal5 = procent(e);
_delay_ms(szybkosc);
}
}
if( e>za5)
{
for( e=kanal5; e>za5; e--)
{
kanal5 = procent(e);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 6 ----------------------------------*/
if( f<za6)
{
for( f=kanal6; f<za6; f++)
{
kanal6 = procent(f);
_delay_ms(szybkosc);
}
}
if( f>za6)
{
for( f=kanal6; f>za6; f--)
{
kanal6 = procent(f);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 7 ----------------------------------*/
if( g<za7)
{
for( g=kanal7; g<za7; g++)
{
kanal7 = procent(g);
_delay_ms(szybkosc);
}
}
if( g>za7)
{
for( g=kanal7; g>za7; g--)
{
kanal7 = procent(g);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 8 ----------------------------------*/
if( h<za8)
{
for( h=kanal8; h<za8; h++)
{
kanal8 = procent(h);
_delay_ms(szybkosc);
}
}
if( h>za8)
{
for( h=kanal8; h>za8; h--)
{
kanal8 = procent(h);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 9 ----------------------------------*/
if( i<za9)
{
for( i=kanal9; i<za9; i++)
{
kanal9 = procent(i);
_delay_ms(szybkosc);
}
}
if( i>za9)
{
for( i=kanal9; i>za9; i--)
{
kanal1 = procent(i);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 10 ----------------------------------*/
if( j<za10)
{
for( j=kanal10; j<za10; j++)
{
kanal10 = procent(j);
_delay_ms(szybkosc);
}
}
if( j>za10)
{
for( j=kanal10; j>za10; j--)
{
kanal10 = procent(j);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 11 ----------------------------------*/
if( k<za11)
{
for( k=kanal11; k<za11; k++)
{
kanal11 = procent(k);
_delay_ms(szybkosc);
}
}
if( k>za11)
{
for( k=kanal11; k>za11; k--)
{
kanal11 = procent(k);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 12 ----------------------------------*/
if( l<za12)
{
for( l=kanal12; l<za12; l++)
{
kanal12 = procent(l);
_delay_ms(szybkosc);
}
}
if( l>za12)
{
for( l=kanal12; l>za12; l--)
{
kanal12 = procent(l);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 13 ----------------------------------*/
if( m<za13)
{
for( m=kanal13; m<za1; m++)
{
kanal13 = procent(m);
_delay_ms(szybkosc);
}
}
if( m>za13)
{
for( m=kanal13; m>za13; m--)
{
kanal13 = procent(m);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 14 ----------------------------------*/
if( n<za14)
{
for( n=kanal14; n<za14; n++)
{
kanal14 = procent(n);
_delay_ms(szybkosc);
}
}
if( n>za14)
{
for( n=kanal14; n>za14; n--)
{
kanal14 = procent(n);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 15 ----------------------------------*/
if( o<za15)
{
for( o=kanal15; o<za15; o++)
{
kanal15 = procent(o);
_delay_ms(szybkosc);
}
}
if( o>za15)
{
for( o=kanal15; o>za15; o--)
{
kanal15 = procent(o);
_delay_ms(szybkosc);
}
}
/* ----------------------- Żarówka 16 ----------------------------------*/
if( p<za16)
{
for( p=kanal16; p<za16; p++)
{
kanal16 = procent(p);
_delay_ms(szybkosc);
}
}
if( p>za16)
{
for( p=kanal16; p>za16; p--)
{
kanal16 = procent(p);
_delay_ms(szybkosc);
}
}
( void )eMBPoll( );
/* Here we simply count the number of poll cycles. */
za1 = usRegHoldingBuf[0];
za2 = usRegHoldingBuf[1];
za3 = usRegHoldingBuf[2];
za4 = usRegHoldingBuf[3];
za5 = usRegHoldingBuf[4];
za6 = usRegHoldingBuf[5];
za7 = usRegHoldingBuf[6];
za8 = usRegHoldingBuf[7];
za9 = usRegHoldingBuf[8];
za10 = usRegHoldingBuf[9];
za11 = usRegHoldingBuf[10];
za12 = usRegHoldingBuf[11];
za13 = usRegHoldingBuf[12];
za14 = usRegHoldingBuf[13];
za15 = usRegHoldingBuf[14];
za16 = usRegHoldingBuf[15];
}
}
eMBErrorCode
eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
{
eMBErrorCode eStatus = MB_ENOERR;
int iRegIndex;
if( ( usAddress >= REG_INPUT_START )
&& ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
{
iRegIndex = ( int )( usAddress - usRegInputStart );
while( usNRegs > 0 )
{
*pucRegBuffer++ =
( unsigned char )( usRegInputBuf[iRegIndex] >> 8 );
*pucRegBuffer++ =
( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF );
iRegIndex++;
usNRegs--;
}
}
else
{
eStatus = MB_ENOREG;
}
return eStatus;
}
eMBErrorCode
eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
{
eMBErrorCode eStatus = MB_ENOERR;
int iRegIndex;
if( ( usAddress >= REG_HOLDING_START ) &&
( usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS ) )
{
iRegIndex = ( int )( usAddress - usRegHoldingStart );
switch ( eMode )
{
/* Pass current register values to the protocol stack. */
case MB_REG_READ:
while( usNRegs > 0 )
{
*pucRegBuffer++ = ( unsigned char )( usRegHoldingBuf[iRegIndex] >> 8 );
*pucRegBuffer++ = ( unsigned char )( usRegHoldingBuf[iRegIndex] & 0xFF );
iRegIndex++;
usNRegs--;
}
break;
/* Update current register values with new values from the
* protocol stack. */
case MB_REG_WRITE:
while( usNRegs > 0 )
{
usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
iRegIndex++;
usNRegs--;
}
}
}
else
{
eStatus = MB_ENOREG;
}
return eStatus;
}
eMBErrorCode
eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils,
eMBRegisterMode eMode )
{
return MB_ENOREG;
}
eMBErrorCode
eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
{
return MB_ENOREG;
}
ISR(INT0_vect) {
TIMER2_STOP;
T_ZAR1_OFF;
kroki=LICZBA_KROKOW;
/* podwójne buforowanie, synchronizacja do 50Hz */
ika1=kanal1;
TCNT2 = 0;
TIMER2_START;
}
ISR(TIMER2_COMP_vect) {
if(ika1 && kroki == ika1) T_ZAR1_ON;
kroki--;
}[/syntax]Statystyki: Napisane przez llemar — 11 lis 2014, o 22:41
]]>
