AVR Freaks

You've suggested that this is part of a school class - surely, that should be teaching you how to do this?

If you haven't reached that point yet, it may be better to put effort into really understanding the bits you have done - rather than run ahead and possibly miss important bits?

Speak to your teacher for recommendations on appropriate "extra work" (s)he will be able to recommend stuff that will really help in the progress of the class.

For getting your outline design - or "skeleton" - you should not be jumping straight to code. Certainly not to assembly code!

Assembler is fine-detail - not overview!

Get a pencil and paper (or virtual equivalent) and draw some block diagrams.

Think about

• what are your inputs?
• what are your outputs?
• what processing needs to be done on the inputs to give you the outputs
• etc, ...

.ORG 0
	JMP MAIN
.ORG 0x02
	JMP E1
.ORG 0x04
	JMP	E2
.ORG 0x1C
	JMP T1
.ORG 0x1E
	JMP T2

Just to note that this could be a lot more readable and portable if you wrote:

.ORG 0
	JMP MAIN
.ORG INT0addr
	JMP E1
.ORG INT1Addr
	JMP	E2
.ORG OC0Aaddr
	JMP T1
.ORG OC0Baddr
	JMP T2

The full list of 328p vector names are in the m328pdef.inc file:

; ***** INTERRUPT VECTORS ************************************************
.equ	INT0addr	= 0x0002	; External Interrupt Request 0
.equ	INT1addr	= 0x0004	; External Interrupt Request 1
.equ	PCI0addr	= 0x0006	; Pin Change Interrupt Request 0
.equ	PCI1addr	= 0x0008	; Pin Change Interrupt Request 0
.equ	PCI2addr	= 0x000a	; Pin Change Interrupt Request 1
.equ	WDTaddr	= 0x000c	; Watchdog Time-out Interrupt
.equ	OC2Aaddr	= 0x000e	; Timer/Counter2 Compare Match A
.equ	OC2Baddr	= 0x0010	; Timer/Counter2 Compare Match A
.equ	OVF2addr	= 0x0012	; Timer/Counter2 Overflow
.equ	ICP1addr	= 0x0014	; Timer/Counter1 Capture Event
.equ	OC1Aaddr	= 0x0016	; Timer/Counter1 Compare Match A
.equ	OC1Baddr	= 0x0018	; Timer/Counter1 Compare Match B
.equ	OVF1addr	= 0x001a	; Timer/Counter1 Overflow
.equ	OC0Aaddr	= 0x001c	; TimerCounter0 Compare Match A
.equ	OC0Baddr	= 0x001e	; TimerCounter0 Compare Match B
.equ	OVF0addr	= 0x0020	; Timer/Couner0 Overflow
.equ	SPIaddr	= 0x0022	; SPI Serial Transfer Complete
.equ	URXCaddr	= 0x0024	; USART Rx Complete
.equ	UDREaddr	= 0x0026	; USART, Data Register Empty
.equ	UTXCaddr	= 0x0028	; USART Tx Complete
.equ	ADCCaddr	= 0x002a	; ADC Conversion Complete
.equ	ERDYaddr	= 0x002c	; EEPROM Ready
.equ	ACIaddr	= 0x002e	; Analog Comparator
.equ	TWIaddr	= 0x0030	; Two-wire Serial Interface
.equ	SPMRaddr	= 0x0032	; Store Program Memory Read

This has the advantage that if you later scale the code down into an 88p or a 48P then for those your code remains the same (almost) but the actual addresses are:

; ***** INTERRUPT VECTORS ************************************************
.equ	INT0addr	= 0x0001	; External Interrupt Request 0
.equ	INT1addr	= 0x0002	; External Interrupt Request 1
.equ	PCI0addr	= 0x0003	; Pin Change Interrupt Request 0
.equ	PCI1addr	= 0x0004	; Pin Change Interrupt Request 0
.equ	PCI2addr	= 0x0005	; Pin Change Interrupt Request 1
.equ	WDTaddr	= 0x0006	; Watchdog Time-out Interrupt
.equ	OC2Aaddr	= 0x0007	; Timer/Counter2 Compare Match A
.equ	OC2Baddr	= 0x0008	; Timer/Counter2 Compare Match A
.equ	OVF2addr	= 0x0009	; Timer/Counter2 Overflow
.equ	ICP1addr	= 0x000a	; Timer/Counter1 Capture Event
.equ	OC1Aaddr	= 0x000b	; Timer/Counter1 Compare Match A
.equ	OC1Baddr	= 0x000c	; Timer/Counter1 Compare Match B
.equ	OVF1addr	= 0x000d	; Timer/Counter1 Overflow
.equ	OC0Aaddr	= 0x000e	; TimerCounter0 Compare Match A
.equ	OC0Baddr	= 0x000f	; TimerCounter0 Compare Match B
.equ	OVF0addr	= 0x0010	; Timer/Couner0 Overflow
.equ	SPIaddr	= 0x0011	; SPI Serial Transfer Complete
.equ	URXCaddr	= 0x0012	; USART Rx Complete
.equ	UDREaddr	= 0x0013	; USART, Data Register Empty
.equ	UTXCaddr	= 0x0014	; USART Tx Complete
.equ	ADCCaddr	= 0x0015	; ADC Conversion Complete
.equ	ERDYaddr	= 0x0016	; EEPROM Ready
.equ	ACIaddr	= 0x0017	; Analog Comparator
.equ	TWIaddr	= 0x0018	; Two-wire Serial Interface
.equ	SPMRaddr	= 0x0019	; Store Program Memory Read

You would, however have to change the JMPs into RJMPs - BTW, unless the vector handlers are a long way from the IVT you may want to do that anyway. The handlers need to be in the first 4K though. (so consider placing them after the IVT but before "MAIN:")

Explain the design. How does this actually work?

(I wouldn't ask this if there had been comments in there to explain what each part was doing).

Well that helps but the design is still not clear from simply reading the code/comments. I can see there are two motors that seem to PWM pulsed on/off by the A/B matches on timers 0 and 2 - can we guess (because it doesn't say) that those are driving th left/right wheels so presumably you "steer" by increasing the speed on one side and decreasing it on the other - presumably that's what the 30/60 compare values are all about?

But the whole INT0/INT1 thing escapes me. Am I supposed to guess that there is some kind of optical sensor or rather two optical sensors and they are some how wired to create INT0/INt1 interrupts?

Put yourself in my place - if you didn't know the circuit/schematic and all you were presented was that code with the comments you have now added do you think it entirely explains how things are connected and how the design is supposed to work?

In professional engineering projects there's usually (I hope!) a third element. There's not only a schematic (or at least "system diagram") that shows how everything is wired - what the inputs and outputs are and there's also the hopefully heavily commented code that gives a narrative about what it's setting up or what it is reading in and how it's attempting to do the controlling job but perhaps the most important is the requirements/specification that is a document (even better with some pictures) that says exactly what the thing is and what it is designed to do. Usually you spend the first few months writing that document to try and capture all that the device will do and how it will work and it naturally leads on to the design of both the circuit and the software to then implement that design requirement.

Modern engineering students seem to be taught the schematic/wiring thing and the coding thing but no one bothers to tell them that they have to spend time (a LOT of time) up front thinking about how the design will actually work.

I know modern world time pressures say that we must get something going as fast as possible but in reality you pay more (in terms of time and effort) from not planning/designing than if you had done that upfront.

Anyway the bottom line is the line following is rarely as easy as just a yes/no decision about "line lost on right, turn back towards it a bit". There's book and myriad internet articles about how to do this. I think you'll find that some of this involves concepts like PID. That's a bit like a lift driving to the 7th floor. You don't just run the motor until a sensor says "here's the 7th, stop". You drive for a while and as you approach the floor you are aiming for you gradually back off until you come to a smooth stop where you want to be. Heating controls are also a but like this. Your central heating doesn't just burn fiercely until it's exactly at the target temperature but it backs off a bit as it gets closer.

So I think you'll find that robot steering equally is rarely about bang-bang, on-off control but that as you approach where you want to be you make smaller and smaller adjustments. In other word you hard coded 30/60 pules width values may not be exactly the solution you require.

But like I say a LOT has been written about line followers so all this has been worked out before you. True a lot is probably in C or C++ or Java or something but the point is that whether you write Asm or whatever the concept/algorithm likely remains the same - it's just coded differently. So I'd read some background design research about this first - find out how this should be done - then write your Asm (and possibly redesign your electronics) to match.

EDIT: for example I googled "line follower robot design" and one of the top hits was:  https://www.researchgate.net/publication/224132741_A_line_follower_robot_from_design_to_implementation_Technical_issues_and_problems . I'm not suggesting that first hit is the solution but after you have read the first 50 or 100 articles like that you should have a much clearer picture about how to approach this.

Why are you setting DDRD twice with different values, is this a typo?

Jim

DUH( head slap) my asm is a bit rusty, OP is setting two bits on the same port!  Sorry

I think the point is that core of your program is:

HERE:

	JMP HERE

If you aren't doing anything else here then you might as well move the sensor reading into this.

Eh ??!